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

package/src/generators/ng-add/files/root-karma/karma.conf.js__tmpl__

@@ -0,0 +1,43 @@
+// Karma configuration file, see link for more information
+// https://karma-runner.github.io/1.0/config/configuration-file.html
+
+const { join } = require('path');
+const { constants } = require('karma');
+
+module.exports = () => {
+  return {
+    basePath: '',
+    frameworks: ['jasmine', '@angular-devkit/build-angular'],
+    plugins: [
+      require('karma-jasmine'),
+      require('karma-chrome-launcher'),
+      require('karma-jasmine-html-reporter'),
+      require('karma-coverage'),
+      require('@angular-devkit/build-angular/plugins/karma'),
+    ],
+    client: {
+      jasmine: {
+        // you can add configuration options for Jasmine here
+        // the possible options are listed at https://jasmine.github.io/api/edge/Configuration.html
+        // for example, you can disable the random execution with `random: false`
+        // or set a specific seed with `seed: 4321`
+      },
+      clearContext: false, // leave Jasmine Spec Runner output visible in browser
+    },
+    jasmineHtmlReporter: {
+      suppressAll: true, // removes the duplicated traces
+    },
+    coverageReporter: {
+      dir: join(__dirname, './coverage'),
+      subdir: '.',
+      reporters: [{ type: 'html' }, { type: 'text-summary' }],
+    },
+    reporters: ['progress', 'kjhtml'],
+    port: 9876,
+    colors: true,
+    logLevel: constants.LOG_INFO,
+    autoWatch: true,
+    browsers: ['Chrome'],
+    singleRun: true,
+  };
+};

package/src/generators/ng-add/migrate-from-angular-cli.d.ts

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

package/src/generators/ng-add/migrate-from-angular-cli.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateFromAngularCli = void 0;
+const devkit_1 = require("@nx/devkit");
+const migrators_1 = require("./migrators");
+const utilities_1 = require("./utilities");
+async function migrateFromAngularCli(tree, options) {
+    (0, utilities_1.validateWorkspace)(tree);
+    const projects = (0, utilities_1.getAllProjects)(tree);
+    const angularJson = (0, devkit_1.readJson)(tree, 'angular.json');
+    (0, utilities_1.ensureAngularDevKitPeerDependenciesAreInstalled)(tree);
+    const migrators = [
+        ...projects.apps.map((app) => new migrators_1.AppMigrator(tree, options, app)),
+        ...projects.libs.map((lib) => new migrators_1.LibMigrator(tree, options, lib)),
+    ];
+    const workspaceRootFileTypesInfo = (0, utilities_1.getWorkspaceRootFileTypesInfo)(tree, migrators);
+    /**
+     * Keep a copy of the root eslint config to restore it later. We need to
+     * do this because the root config can also be the config for the app at
+     * the root of the Angular CLI workspace and it will be moved as part of
+     * the app migration.
+     */
+    let eslintConfig = workspaceRootFileTypesInfo.eslint && tree.exists('.eslintrc.json')
+        ? (0, devkit_1.readJson)(tree, '.eslintrc.json')
+        : undefined;
+    // create and update root files and configurations
+    (0, devkit_1.updateJson)(tree, 'angular.json', (json) => ({
+        ...json,
+        version: 2,
+        $schema: undefined,
+    }));
+    (0, utilities_1.createNxJson)(tree, options, angularJson.defaultProject);
+    (0, utilities_1.updateWorkspaceConfigDefaults)(tree);
+    (0, utilities_1.updateRootTsConfig)(tree);
+    (0, utilities_1.updatePackageJson)(tree);
+    await (0, utilities_1.createWorkspaceFiles)(tree);
+    // migrate all projects
+    for (const migrator of migrators) {
+        await migrator.migrate();
+    }
+    /**
+     * This needs to be done last because the Angular CLI workspace can have
+     * these files in the root for the root application, so we wait until
+     * those root config files are moved when the projects are migrated.
+     */
+    if (workspaceRootFileTypesInfo.karma) {
+        (0, utilities_1.createRootKarmaConfig)(tree);
+    }
+    if (workspaceRootFileTypesInfo.eslint) {
+        await (0, utilities_1.updateRootEsLintConfig)(tree, eslintConfig, options.unitTestRunner);
+        (0, utilities_1.cleanupEsLintPackages)(tree);
+    }
+    (0, utilities_1.deleteGitKeepFilesIfNotNeeded)(tree);
+    (0, utilities_1.deleteAngularJson)(tree);
+    if (!options.skipInstall) {
+        return () => {
+            (0, devkit_1.installPackagesTask)(tree);
+            (0, utilities_1.formatFilesTask)(tree);
+        };
+    }
+}
+exports.migrateFromAngularCli = migrateFromAngularCli;

package/src/generators/ng-add/migrators/builders/angular-devkit-karma.migrator.d.ts

@@ -0,0 +1,9 @@
+import type { ProjectConfiguration, Tree } from '@nx/devkit';
+import type { Logger, ProjectMigrationInfo } from '../../utilities';
+import { BuilderMigrator } from './builder.migrator';
+export declare class AngularDevkitKarmaMigrator extends BuilderMigrator {
+    constructor(tree: Tree, project: ProjectMigrationInfo, projectConfig: ProjectConfiguration, logger: Logger);
+    migrate(): void;
+    private updateTargetConfiguration;
+    private updateTsConfigFileUsedByTestTarget;
+}

package/src/generators/ng-add/migrators/builders/angular-devkit-karma.migrator.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AngularDevkitKarmaMigrator = void 0;
+const devkit_1 = require("@nx/devkit");
+const js_1 = require("@nx/js");
+const path_1 = require("path");
+const builder_migrator_1 = require("./builder.migrator");
+class AngularDevkitKarmaMigrator extends builder_migrator_1.BuilderMigrator {
+    constructor(tree, project, projectConfig, logger) {
+        super(tree, '@angular-devkit/build-angular:karma', 'karma', project, projectConfig, logger);
+    }
+    migrate() {
+        if (this.skipMigration) {
+            return;
+        }
+        for (const [name, target] of this.targets) {
+            this.moveFilePathsFromTargetToProjectRoot(target, [
+                'karmaConfig',
+                'tsConfig',
+                'webWorkerTsConfig',
+            ]);
+            this.updateTargetConfiguration(name, target);
+            this.updateTsConfigFileUsedByTestTarget(name, target);
+            this.updateCacheableOperations([name]);
+        }
+        if (!this.targets.size && this.projectConfig.root === '') {
+            // there could still be a karma.conf.js file in the root
+            // so move to new location
+            const karmaConfig = 'karma.conf.js';
+            if (this.tree.exists(karmaConfig)) {
+                this.logger.info('No "test" target was found, but a root Karma config file was found in the project root. The file will be moved to the new location.');
+                this.moveProjectRootFile(karmaConfig);
+            }
+        }
+    }
+    updateTargetConfiguration(targetName, target) {
+        if (!target.options) {
+            this.logger.warn(`The target "${targetName}" is not specifying any options. Skipping updating the target configuration.`);
+            return;
+        }
+        target.options.main =
+            target.options.main && this.convertAsset(target.options.main);
+        target.options.polyfills = Array.isArray(target.options.polyfills)
+            ? target.options.polyfills.map((p) => this.convertAsset(p))
+            : target.options.polyfills && this.convertAsset(target.options.polyfills);
+        target.options.tsConfig =
+            target.options.tsConfig &&
+                (0, devkit_1.joinPathFragments)(this.project.newRoot, (0, path_1.basename)(target.options.tsConfig));
+        target.options.karmaConfig =
+            target.options.karmaConfig &&
+                (0, devkit_1.joinPathFragments)(this.project.newRoot, (0, path_1.basename)(target.options.karmaConfig));
+        target.options.assets =
+            target.options.assets &&
+                target.options.assets.map((asset) => this.convertAsset(asset));
+        target.options.styles =
+            target.options.styles &&
+                target.options.styles.map((style) => this.convertAsset(style));
+        target.options.scripts =
+            target.options.scripts &&
+                target.options.scripts.map((script) => this.convertAsset(script));
+        (0, devkit_1.updateProjectConfiguration)(this.tree, this.project.name, {
+            ...this.projectConfig,
+        });
+    }
+    updateTsConfigFileUsedByTestTarget(targetName, target) {
+        if (!target.options?.tsConfig) {
+            this.logger.warn(`The "${targetName}" target does not have the "tsConfig" option configured. Skipping updating the tsConfig file.`);
+            return;
+        }
+        if (!this.tree.exists(target.options.tsConfig)) {
+            const originalTsConfigPath = this.originalProjectConfig.targets[targetName].options.tsConfig;
+            this.logger.warn(`The tsConfig file "${originalTsConfigPath}" specified in the "${targetName}" target could not be found. Skipping updating the tsConfig file.`);
+            return;
+        }
+        this.updateTsConfigFile(target.options.tsConfig, (0, js_1.getRootTsConfigPathInTree)(this.tree), (0, devkit_1.offsetFromRoot)(this.projectConfig.root));
+    }
+}
+exports.AngularDevkitKarmaMigrator = AngularDevkitKarmaMigrator;

package/src/generators/ng-add/migrators/builders/angular-devkit-ng-packagr.migrator.d.ts

@@ -0,0 +1,10 @@
+import type { ProjectConfiguration, Tree } from '@nx/devkit';
+import type { Logger, ProjectMigrationInfo } from '../../utilities';
+import { BuilderMigrator } from './builder.migrator';
+export declare class AngularDevkitNgPackagrMigrator extends BuilderMigrator {
+    constructor(tree: Tree, project: ProjectMigrationInfo, projectConfig: ProjectConfiguration, logger: Logger);
+    migrate(): void;
+    private updateTargetConfiguration;
+    private updateNgPackageJson;
+    private updateTsConfigs;
+}

package/src/generators/ng-add/migrators/builders/angular-devkit-ng-packagr.migrator.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AngularDevkitNgPackagrMigrator = void 0;
+const devkit_1 = require("@nx/devkit");
+const js_1 = require("@nx/js");
+const path_1 = require("path");
+const dependencies_1 = require("../../../utils/dependencies");
+const builder_migrator_1 = require("./builder.migrator");
+class AngularDevkitNgPackagrMigrator extends builder_migrator_1.BuilderMigrator {
+    constructor(tree, project, projectConfig, logger) {
+        super(tree, '@angular-devkit/build-angular:ng-packagr', undefined, project, projectConfig, logger);
+    }
+    migrate() {
+        if (this.skipMigration) {
+            return;
+        }
+        if (!this.targets.size) {
+            this.logger.warn(`There is no target in the project configuration using the ${this.builderName} builder. This might not be an issue. ` +
+                `Skipping updating the build configuration.`);
+            return;
+        }
+        for (const [name, target] of this.targets) {
+            this.updateTargetConfiguration(name, target);
+            this.updateNgPackageJson(name, target);
+            this.updateTsConfigs(name, target);
+            this.updateCacheableOperations([name]);
+            (0, dependencies_1.addBuildableLibrariesPostCssDependencies)(this.tree);
+        }
+    }
+    updateTargetConfiguration(targetName, target) {
+        target.executor = '@nx/angular:package';
+        if (!target.options &&
+            (!target.configurations || !Object.keys(target.configurations).length)) {
+            this.logger.warn(`The target "${targetName}" is not specifying any options or configurations. Skipping updating the target configuration.`);
+            return;
+        }
+        ['project', 'tsConfig'].forEach((option) => {
+            if (target.options?.[option]) {
+                target.options[option] = (0, devkit_1.joinPathFragments)(this.project.newRoot, (0, path_1.basename)(target.options[option]));
+            }
+            for (const configuration of Object.values(target.configurations ?? {})) {
+                configuration[option] =
+                    configuration[option] &&
+                        (0, devkit_1.joinPathFragments)(this.project.newRoot, (0, path_1.basename)(configuration[option]));
+            }
+        });
+        (0, devkit_1.updateProjectConfiguration)(this.tree, this.project.name, {
+            ...this.projectConfig,
+        });
+    }
+    updateNgPackageJson(targetName, target) {
+        if (!target.options?.project) {
+            this.logger.warn(`The "${targetName}" target does not have the "project" option configured. Skipping updating the ng-packagr project file ("ng-package.json").`);
+            return;
+        }
+        else if (!this.tree.exists(target.options.project)) {
+            this.logger.warn(`The ng-packagr project file "${this.originalProjectConfig.targets[targetName].options.project}" specified in the "${targetName}" ` +
+                `target could not be found. Skipping updating the ng-packagr project file.`);
+            return;
+        }
+        (0, devkit_1.updateJson)(this.tree, target.options.project, (ngPackageJson) => {
+            const offset = (0, devkit_1.offsetFromRoot)(this.project.newRoot);
+            ngPackageJson.$schema =
+                ngPackageJson.$schema &&
+                    `${offset}node_modules/ng-packagr/ng-package.schema.json`;
+            ngPackageJson.dest = `${offset}dist/${this.project.name}`;
+            return ngPackageJson;
+        });
+    }
+    updateTsConfigs(targetName, target) {
+        const tsConfigPath = target.options?.tsConfig ?? target.configurations?.development?.tsConfig;
+        if (!tsConfigPath) {
+            this.logger.warn(`The "${targetName}" target does not have the "tsConfig" option configured. Skipping updating the tsConfig file.`);
+            return;
+        }
+        else if (!this.tree.exists(tsConfigPath)) {
+            const originalTsConfigPath = target.options?.tsConfig
+                ? this.originalProjectConfig.targets[targetName].options.tsConfig
+                : this.originalProjectConfig.targets[targetName].configurations
+                    ?.development?.tsConfig;
+            this.logger.warn(`The tsConfig file "${originalTsConfigPath}" specified in the "${targetName}" target could not be found. Skipping updating the tsConfig file.`);
+            return;
+        }
+        const rootTsConfigFile = (0, js_1.getRootTsConfigPathInTree)(this.tree);
+        const projectOffsetFromRoot = (0, devkit_1.offsetFromRoot)(this.projectConfig.root);
+        this.updateTsConfigFile(tsConfigPath, rootTsConfigFile, projectOffsetFromRoot);
+        (0, devkit_1.updateJson)(this.tree, tsConfigPath, (json) => {
+            if (!json.include?.length && !json.files?.length) {
+                json.include = ['**/*.ts'];
+            }
+            return json;
+        });
+    }
+}
+exports.AngularDevkitNgPackagrMigrator = AngularDevkitNgPackagrMigrator;

package/src/generators/ng-add/migrators/builders/angular-eslint-lint.migrator.d.ts

@@ -0,0 +1,12 @@
+import type { ProjectConfiguration, Tree } from '@nx/devkit';
+import type { Logger, ProjectMigrationInfo } from '../../utilities';
+import { BuilderMigrator } from './builder.migrator';
+export declare class AngularEslintLintMigrator extends BuilderMigrator {
+    private oldEsLintConfigPath;
+    private newEsLintConfigPath;
+    constructor(tree: Tree, project: ProjectMigrationInfo, projectConfig: ProjectConfiguration, logger: Logger);
+    migrate(): void;
+    private updateTargetConfiguration;
+    private updateEsLintConfig;
+    private convertEsLintConfigExtendToNewPath;
+}

package/src/generators/ng-add/migrators/builders/angular-eslint-lint.migrator.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AngularEslintLintMigrator = void 0;
+const devkit_1 = require("@nx/devkit");
+const eslint_1 = require("@nx/eslint");
+const path_1 = require("path");
+const builder_migrator_1 = require("./builder.migrator");
+class AngularEslintLintMigrator extends builder_migrator_1.BuilderMigrator {
+    constructor(tree, project, projectConfig, logger) {
+        super(tree, '@angular-eslint/builder:lint', 'eslint', project, projectConfig, logger);
+    }
+    migrate() {
+        if (this.skipMigration) {
+            return;
+        }
+        for (const [name, target] of this.targets) {
+            this.oldEsLintConfigPath =
+                target.options?.eslintConfig ??
+                    (0, devkit_1.joinPathFragments)(this.project.oldRoot, '.eslintrc.json');
+            this.newEsLintConfigPath = this.convertRootPath(this.oldEsLintConfigPath);
+            this.moveProjectRootFile(this.oldEsLintConfigPath);
+            this.updateTargetConfiguration(name, target);
+            this.updateEsLintConfig();
+            this.updateCacheableOperations([name]);
+        }
+        if (!this.targets.size && this.projectConfig.root === '') {
+            // there could still be a .eslintrc.json file in the root
+            // so move to new location
+            const eslintConfig = '.eslintrc.json';
+            if (this.tree.exists(eslintConfig)) {
+                this.logger.info('No "lint" target was found, but an ESLint config file was found in the project root. The file will be moved to the new location.');
+                this.moveProjectRootFile(eslintConfig);
+            }
+        }
+    }
+    async updateTargetConfiguration(targetName, target) {
+        target.executor = '@nx/eslint:lint';
+        if (!target.options) {
+            this.logger.warn(`The target "${targetName}" is not specifying any options. Skipping updating the target configuration.`);
+            return;
+        }
+        const existEsLintConfigPath = this.tree.exists(this.newEsLintConfigPath);
+        if (!existEsLintConfigPath) {
+            this.logger.warn(`The ESLint config file "${this.oldEsLintConfigPath}" could not be found. Skipping updating the file.`);
+        }
+        target.options.eslintConfig =
+            target.options.eslintConfig && this.newEsLintConfigPath;
+        target.options.lintFilePatterns =
+            target.options.lintFilePatterns &&
+                target.options.lintFilePatterns.map((pattern) => {
+                    // replace the old source root with the new root, we want to lint all
+                    // matching files in the project, not just the ones in the source root
+                    if (pattern.startsWith(this.project.oldSourceRoot)) {
+                        return (0, devkit_1.joinPathFragments)(this.project.newRoot, pattern.replace(this.project.oldSourceRoot, ''));
+                    }
+                    // replace the old root with the new root
+                    if (pattern.startsWith(this.project.oldRoot)) {
+                        return (0, devkit_1.joinPathFragments)(this.project.newRoot, pattern.replace(this.project.oldRoot, ''));
+                    }
+                    // do nothing, warn about the pattern
+                    this.logger.warn(`The lint file pattern "${pattern}" specified in the "${targetName}" target is not contained in the project root or source root. The pattern will not be updated.`);
+                    return pattern;
+                });
+        if (existEsLintConfigPath) {
+            const eslintConfig = (0, devkit_1.readJson)(this.tree, this.newEsLintConfigPath);
+            if ((0, eslint_1.hasRulesRequiringTypeChecking)(eslintConfig)) {
+                target.options.hasTypeAwareRules = true;
+            }
+        }
+        (0, devkit_1.updateProjectConfiguration)(this.tree, this.project.name, {
+            ...this.projectConfig,
+        });
+    }
+    updateEsLintConfig() {
+        if (!this.tree.exists(this.newEsLintConfigPath)) {
+            return;
+        }
+        (0, devkit_1.updateJson)(this.tree, this.newEsLintConfigPath, (json) => {
+            delete json.root;
+            json.ignorePatterns = ['!**/*'];
+            const rootEsLintConfigRelativePath = (0, devkit_1.joinPathFragments)((0, devkit_1.offsetFromRoot)(this.projectConfig.root), '.eslintrc.json');
+            if (Array.isArray(json.extends)) {
+                json.extends = json.extends.map((extend) => this.convertEsLintConfigExtendToNewPath(this.oldEsLintConfigPath, extend));
+                // it might have not been extending from the root config, make sure it does
+                if (!json.extends.includes(rootEsLintConfigRelativePath)) {
+                    json.extends.unshift(rootEsLintConfigRelativePath);
+                }
+            }
+            else {
+                json.extends = rootEsLintConfigRelativePath;
+            }
+            json.overrides?.forEach((override) => {
+                if (!override.parserOptions?.project) {
+                    return;
+                }
+                override.parserOptions.project = [
+                    `${this.projectConfig.root}/tsconfig.*?.json`,
+                ];
+            });
+            return json;
+        });
+    }
+    convertEsLintConfigExtendToNewPath(eslintConfigPath, extendPath) {
+        if (!extendPath.startsWith('..')) {
+            // we only need to adjust paths that are on a different directory, files
+            // in the same directory are moved together so their relative paths are
+            // not changed
+            return extendPath;
+        }
+        return (0, devkit_1.joinPathFragments)((0, devkit_1.offsetFromRoot)(this.project.newRoot), (0, path_1.dirname)(eslintConfigPath), extendPath);
+    }
+}
+exports.AngularEslintLintMigrator = AngularEslintLintMigrator;

package/src/generators/ng-add/migrators/builders/builder-migrator-class.type.d.ts

@@ -0,0 +1,6 @@
+import type { ProjectConfiguration, Tree } from '@nx/devkit';
+import type { Logger, ProjectMigrationInfo } from '../../utilities';
+import type { BuilderMigrator } from './builder.migrator';
+export type BuilderMigratorClassType = {
+    new (tree: Tree, project: ProjectMigrationInfo, projectConfig: ProjectConfiguration, logger: Logger): BuilderMigrator;
+};

package/src/generators/ng-add/migrators/builders/builder-migrator-class.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/generators/ng-add/migrators/builders/builder.migrator.d.ts

@@ -0,0 +1,13 @@
+import type { ProjectConfiguration, TargetConfiguration, Tree } from '@nx/devkit';
+import type { Logger, ProjectMigrationInfo, ValidationResult, WorkspaceRootFileType } from '../../utilities';
+import { Migrator } from '../migrator';
+export declare abstract class BuilderMigrator extends Migrator {
+    readonly builderName: string;
+    readonly rootFileType: WorkspaceRootFileType | undefined;
+    targets: Map<string, TargetConfiguration>;
+    protected skipMigration: boolean;
+    constructor(tree: Tree, builderName: string, rootFileType: WorkspaceRootFileType | undefined, project: ProjectMigrationInfo, projectConfig: ProjectConfiguration, logger: Logger);
+    validate(): ValidationResult;
+    isBuilderUsed(): boolean;
+    protected collectBuilderTargets(): void;
+}

package/src/generators/ng-add/migrators/builders/builder.migrator.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuilderMigrator = void 0;
+const utilities_1 = require("../../utilities");
+const migrator_1 = require("../migrator");
+class BuilderMigrator extends migrator_1.Migrator {
+    constructor(tree, builderName, rootFileType, project, projectConfig, logger) {
+        super(tree, projectConfig, logger);
+        this.builderName = builderName;
+        this.rootFileType = rootFileType;
+        this.targets = new Map();
+        this.skipMigration = false;
+        this.project = project;
+        this.projectConfig = projectConfig;
+        this.collectBuilderTargets();
+    }
+    validate() {
+        const errors = [];
+        // TODO(leo): keeping restriction until the full refactor is done and we start
+        // expanding what's supported.
+        if (this.targets.size > 1) {
+            errors.push({
+                message: `There is more than one target using the builder "${this.builderName}": ${(0, utilities_1.arrayToString)([
+                    ...this.targets.keys(),
+                ])}. This is not currently supported by the automated migration. These targets will be skipped.`,
+                hint: 'Make sure to manually migrate their configuration and any possible associated files.',
+            });
+            this.skipMigration = true;
+        }
+        return errors.length ? errors : null;
+    }
+    isBuilderUsed() {
+        return this.targets.size > 0;
+    }
+    collectBuilderTargets() {
+        for (const [name, target] of Object.entries(this.projectConfig.targets ?? {})) {
+            if (target.executor === this.builderName) {
+                this.targets.set(name, target);
+            }
+        }
+    }
+}
+exports.BuilderMigrator = BuilderMigrator;

package/src/generators/ng-add/migrators/builders/index.d.ts

@@ -0,0 +1,5 @@
+export * from './angular-devkit-karma.migrator';
+export * from './angular-devkit-ng-packagr.migrator';
+export * from './angular-eslint-lint.migrator';
+export * from './builder-migrator-class.type';
+export * from './builder.migrator';

package/src/generators/ng-add/migrators/builders/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./angular-devkit-karma.migrator"), exports);
+tslib_1.__exportStar(require("./angular-devkit-ng-packagr.migrator"), exports);
+tslib_1.__exportStar(require("./angular-eslint-lint.migrator"), exports);
+tslib_1.__exportStar(require("./builder-migrator-class.type"), exports);
+tslib_1.__exportStar(require("./builder.migrator"), exports);

package/src/generators/ng-add/migrators/index.d.ts

@@ -0,0 +1,2 @@
+export * from './builders';
+export * from './projects';

package/src/generators/ng-add/migrators/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./builders"), exports);
+tslib_1.__exportStar(require("./projects"), exports);

package/src/generators/ng-add/migrators/migrator.d.ts

@@ -0,0 +1,23 @@
+import type { ProjectConfiguration, TargetConfiguration, Tree } from '@nx/devkit';
+import type { Logger } from '../utilities/logger';
+import type { ProjectMigrationInfo, ValidationResult } from '../utilities/types';
+export declare abstract class Migrator {
+    protected readonly tree: Tree;
+    protected projectConfig: ProjectConfiguration;
+    protected readonly logger: Logger;
+    protected project: ProjectMigrationInfo;
+    protected readonly originalProjectConfig: ProjectConfiguration;
+    constructor(tree: Tree, projectConfig: ProjectConfiguration, logger: Logger);
+    abstract migrate(): Promise<void> | void;
+    abstract validate(): ValidationResult;
+    protected convertAsset(asset: string | any): string | any;
+    protected convertRootPath(originalPath: string): string;
+    protected moveFile(from: string, to: string, required?: boolean): void;
+    protected moveFilePathsFromTargetToProjectRoot(target: TargetConfiguration, options: string[]): void;
+    protected moveProjectRootFile(filePath: string, isRequired?: boolean): void;
+    protected updateCacheableOperations(targetNames: string[]): void;
+    protected updateTsConfigFile(tsConfigPath: string, rootTsConfigFile: string, projectOffsetFromRoot: string): void;
+    private convertSourceRootPath;
+    private getTargetValuesForOption;
+    private getValueForOption;
+}