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

package/src/generators/move/lib/normalize-schema.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeSchema = void 0;
+const devkit_1 = require("@nx/devkit");
+const enquirer_1 = require("enquirer");
+const get_import_path_1 = require("../../../utilities/get-import-path");
+const utils_1 = require("./utils");
+async function normalizeSchema(tree, schema, projectConfiguration) {
+    const { destination, newProjectName, importPath } = await determineProjectNameAndRootOptions(tree, schema, projectConfiguration);
+    return {
+        ...schema,
+        destination: (0, utils_1.normalizePathSlashes)(schema.destination),
+        importPath,
+        newProjectName,
+        relativeToRootDestination: destination,
+    };
+}
+exports.normalizeSchema = normalizeSchema;
+async function determineProjectNameAndRootOptions(tree, options, projectConfiguration) {
+    if (!options.projectNameAndRootFormat &&
+        (process.env.NX_INTERACTIVE !== 'true' || !isTTY())) {
+        options.projectNameAndRootFormat = 'derived';
+    }
+    validateName(options.newProjectName, options.projectNameAndRootFormat, projectConfiguration);
+    const formats = getProjectNameAndRootFormats(tree, options, projectConfiguration);
+    const format = options.projectNameAndRootFormat ?? (await determineFormat(formats));
+    if (format === 'derived') {
+        logDeprecationMessage(formats, options);
+    }
+    return formats[format];
+}
+function validateName(name, projectNameAndRootFormat, projectConfiguration) {
+    if (!name) {
+        return;
+    }
+    if (projectNameAndRootFormat === 'derived' && name.startsWith('@')) {
+        throw new Error(`The new project name "${name}" cannot start with "@" when the "projectNameAndRootFormat" is "derived".`);
+    }
+    /**
+     * Matches two types of project names:
+     *
+     * 1. Valid npm package names (e.g., '@scope/name' or 'name').
+     * 2. Names starting with a letter and can contain any character except whitespace and ':'.
+     *
+     * The second case is to support the legacy behavior (^[a-zA-Z].*$) with the difference
+     * that it doesn't allow the ":" character. It was wrong to allow it because it would
+     * conflict with the notation for tasks.
+     */
+    const libraryPattern = '(?:^@[a-zA-Z0-9-*~][a-zA-Z0-9-*._~]*\\/[a-zA-Z0-9-~][a-zA-Z0-9-._~]*|^[a-zA-Z][^:]*)$';
+    const appPattern = '^[a-zA-Z][^:]*$';
+    if (projectConfiguration.projectType === 'application') {
+        const validationRegex = new RegExp(appPattern);
+        if (!validationRegex.test(name)) {
+            throw new Error(`The new project name should match the pattern "${appPattern}". The provided value "${name}" does not match.`);
+        }
+    }
+    else if (projectConfiguration.projectType === 'library') {
+        const validationRegex = new RegExp(libraryPattern);
+        if (!validationRegex.test(name)) {
+            throw new Error(`The new project name should match the pattern "${libraryPattern}". The provided value "${name}" does not match.`);
+        }
+    }
+}
+function getProjectNameAndRootFormats(tree, options, projectConfiguration) {
+    let destination = (0, utils_1.normalizePathSlashes)(options.destination);
+    if (options.newProjectName &&
+        options.newProjectName.includes('/') &&
+        !options.newProjectName.startsWith('@')) {
+        throw new Error(`You can't specify a new project name with a directory path (${options.newProjectName}). ` +
+            `Please provide a valid name without path segments and the full destination with the "--destination" option.`);
+    }
+    const asProvidedOptions = getAsProvidedOptions(tree, { ...options, destination }, projectConfiguration);
+    if (options.projectNameAndRootFormat === 'as-provided') {
+        return {
+            'as-provided': asProvidedOptions,
+            derived: undefined,
+        };
+    }
+    if (asProvidedOptions.newProjectName.startsWith('@')) {
+        if (!options.projectNameAndRootFormat) {
+            devkit_1.output.warn({
+                title: `The provided new project name "${asProvidedOptions.newProjectName}" is a scoped project name and this is not supported by the move generator when using the "derived" format.`,
+                bodyLines: [
+                    `The generator will try to move the project using the "as-provided" format with the new name "${asProvidedOptions.newProjectName}" located at "${asProvidedOptions.destination}".`,
+                ],
+            });
+            return {
+                'as-provided': asProvidedOptions,
+                derived: undefined,
+            };
+        }
+        throw new Error(`The provided new project name "${options.newProjectName}" is a scoped project name and this is not supported by the move generator when using the "derived" format. ` +
+            `Please provide a name without "@" or use the "as-provided" format.`);
+    }
+    const derivedOptions = getDerivedOptions(tree, { ...options, destination }, projectConfiguration);
+    return {
+        'as-provided': asProvidedOptions,
+        derived: derivedOptions,
+    };
+}
+async function determineFormat(formats) {
+    if (!formats.derived) {
+        return 'as-provided';
+    }
+    const asProvidedDescription = `As provided:
+    Name: ${formats['as-provided'].newProjectName}
+    Destination: ${formats['as-provided'].destination}`;
+    const asProvidedSelectedValue = `${formats['as-provided'].newProjectName} @ ${formats['as-provided'].destination}`;
+    const derivedDescription = `Derived:
+    Name: ${formats['derived'].newProjectName}
+    Destination: ${formats['derived'].destination}`;
+    const derivedSelectedValue = `${formats['derived'].newProjectName} @ ${formats['derived'].destination}`;
+    const result = await (0, enquirer_1.prompt)({
+        type: 'select',
+        name: 'format',
+        message: 'What should be the new project name and where should it be moved to?',
+        choices: [
+            {
+                message: asProvidedDescription,
+                name: asProvidedSelectedValue,
+            },
+            {
+                message: derivedDescription,
+                name: derivedSelectedValue,
+            },
+        ],
+        initial: 0,
+    }).then(({ format }) => format === asProvidedSelectedValue ? 'as-provided' : 'derived');
+    return result;
+}
+function logDeprecationMessage(formats, options) {
+    const callingGenerator = process.env.NX_ANGULAR_MOVE_INVOKED === 'true'
+        ? '@nx/angular:move'
+        : '@nx/workspace:move';
+    devkit_1.logger.warn((0, devkit_1.stripIndents) `
+    In Nx 19, the project name and destination will no longer be derived.
+    Please provide the exact new project name and destination in the future.
+    Example: nx g ${callingGenerator} --projectName ${options.projectName} --destination ${formats['derived'].destination}` +
+        (options.projectName !== formats['derived'].newProjectName
+            ? ` --newProjectName ${formats['derived'].newProjectName}`
+            : ''));
+}
+function getAsProvidedOptions(tree, options, projectConfiguration) {
+    const newProjectName = options.newProjectName ?? options.projectName;
+    const destination = options.destination;
+    if (projectConfiguration.projectType !== 'library') {
+        return { destination, newProjectName };
+    }
+    let importPath = options.importPath;
+    if (importPath) {
+        return { destination, newProjectName, importPath };
+    }
+    if (options.newProjectName?.startsWith('@')) {
+        // keep the existing import path if the name didn't change
+        importPath =
+            options.newProjectName && options.projectName !== options.newProjectName
+                ? newProjectName
+                : undefined;
+    }
+    else if (options.newProjectName) {
+        const npmScope = (0, get_import_path_1.getNpmScope)(tree);
+        importPath = npmScope
+            ? `${npmScope === '@' ? '' : '@'}${npmScope}/${newProjectName}`
+            : newProjectName;
+    }
+    return { destination, newProjectName, importPath };
+}
+function getDerivedOptions(tree, options, projectConfiguration) {
+    const newProjectName = options.newProjectName
+        ? (0, devkit_1.names)(options.newProjectName).fileName
+        : (0, utils_1.getNewProjectName)(options.destination);
+    const destination = (0, utils_1.getDestination)(tree, options, projectConfiguration);
+    let importPath;
+    if (projectConfiguration.projectType === 'library') {
+        importPath =
+            options.importPath ??
+                (0, utils_1.normalizePathSlashes)((0, get_import_path_1.getImportPath)(tree, options.destination));
+    }
+    return { destination, newProjectName, importPath };
+}
+function isTTY() {
+    return !!process.stdout.isTTY && process.env['CI'] !== 'true';
+}

package/src/generators/move/lib/run-angular-plugin.d.ts

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

package/src/generators/move/lib/run-angular-plugin.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAngularPlugin = void 0;
+async function runAngularPlugin(tree, schema) {
+    let move;
+    try {
+        // nx-ignore-next-line
+        move = require('@nx/angular/src/generators/move/move-impl').move;
+    }
+    catch { }
+    if (!move) {
+        return;
+    }
+    await move(tree, {
+        oldProjectName: schema.projectName,
+        newProjectName: schema.newProjectName,
+    });
+}
+exports.runAngularPlugin = runAngularPlugin;

package/src/generators/move/lib/update-build-targets.d.ts

@@ -0,0 +1,6 @@
+import { Tree } from '@nx/devkit';
+import { NormalizedSchema } from '../schema';
+/**
+ * Update other references to the source project's targets
+ */
+export declare function updateBuildTargets(tree: Tree, schema: NormalizedSchema): void;

package/src/generators/move/lib/update-build-targets.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateBuildTargets = void 0;
+const devkit_1 = require("@nx/devkit");
+/**
+ * Update other references to the source project's targets
+ */
+function updateBuildTargets(tree, schema) {
+    (0, devkit_1.getProjects)(tree).forEach((projectConfig, project) => {
+        let changed = false;
+        Object.entries(projectConfig.targets || {}).forEach(([target, targetConfig]) => {
+            changed =
+                updateJsonValue(targetConfig, (value) => {
+                    const [project, target, configuration] = value.split(':');
+                    if (project === schema.projectName && target) {
+                        return configuration
+                            ? `${schema.newProjectName}:${target}:${configuration}`
+                            : `${schema.newProjectName}:${target}`;
+                    }
+                }) || changed;
+        });
+        if (changed) {
+            (0, devkit_1.updateProjectConfiguration)(tree, project, projectConfig);
+        }
+    });
+}
+exports.updateBuildTargets = updateBuildTargets;
+function updateJsonValue(config, callback) {
+    function recur(obj, key, value) {
+        let changed = false;
+        if (typeof value === 'string') {
+            const result = callback(value);
+            if (result && obj[key] !== result) {
+                obj[key] = result;
+                changed = true;
+            }
+        }
+        else if (Array.isArray(value)) {
+            value.forEach((x, idx) => recur(value, idx, x));
+        }
+        else if (typeof value === 'object') {
+            Object.entries(value).forEach(([k, v]) => {
+                changed = recur(value, k, v) || changed;
+            });
+        }
+        return changed;
+    }
+    let changed = false;
+    Object.entries(config).forEach(([k, v]) => {
+        changed = recur(config, k, v) || changed;
+    });
+    return changed;
+}

package/src/generators/move/lib/update-cypress-config.d.ts

@@ -0,0 +1,10 @@
+import { ProjectConfiguration, Tree } from '@nx/devkit';
+import { NormalizedSchema } from '../schema';
+/**
+ * Updates the videos and screenshots folders in the cypress.json/cypress.config.ts if it exists (i.e. we're moving an e2e project)
+ *
+ * (assume relative paths have been updated previously)
+ *
+ * @param schema The options provided to the schematic
+ */
+export declare function updateCypressConfig(tree: Tree, schema: NormalizedSchema, project: ProjectConfiguration): Tree;

package/src/generators/move/lib/update-cypress-config.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateCypressConfig = void 0;
+const path = require("path");
+/**
+ * Updates the videos and screenshots folders in the cypress.json/cypress.config.ts if it exists (i.e. we're moving an e2e project)
+ *
+ * (assume relative paths have been updated previously)
+ *
+ * @param schema The options provided to the schematic
+ */
+function updateCypressConfig(tree, schema, project) {
+    const cypressJsonPath = path.join(schema.relativeToRootDestination, 'cypress.json');
+    if (tree.exists(cypressJsonPath)) {
+        const cypressJson = JSON.parse(tree.read(cypressJsonPath).toString('utf-8'));
+        // videosFolder is not required because videos can be turned off - it also has a default
+        if (cypressJson.videosFolder) {
+            cypressJson.videosFolder = cypressJson.videosFolder.replace(project.root, schema.relativeToRootDestination);
+        }
+        // screenshotsFolder is not required as it has a default
+        if (cypressJson.screenshotsFolder) {
+            cypressJson.screenshotsFolder = cypressJson.screenshotsFolder.replace(project.root, schema.relativeToRootDestination);
+        }
+        tree.write(cypressJsonPath, JSON.stringify(cypressJson));
+        return tree;
+    }
+    const cypressConfigPath = path.join(schema.relativeToRootDestination, 'cypress.config.ts');
+    // Search and replace for "e2e" directory is not safe, and will result in an invalid config file.
+    // Leave it and let users fix the config if needed.
+    if (project.root !== 'e2e' && tree.exists(cypressConfigPath)) {
+        const oldContent = tree.read(cypressConfigPath, 'utf-8');
+        const findName = new RegExp(`'${schema.projectName}'`, 'g');
+        const findDir = new RegExp(project.root, 'g');
+        const newContent = oldContent
+            .replace(findName, `'${schema.newProjectName}'`)
+            .replace(findDir, schema.relativeToRootDestination);
+        tree.write(cypressConfigPath, newContent);
+    }
+}
+exports.updateCypressConfig = updateCypressConfig;

package/src/generators/move/lib/update-default-project.d.ts

@@ -0,0 +1,10 @@
+import { Tree } from '@nx/devkit';
+import { NormalizedSchema } from '../schema';
+/**
+ * Updates the project in the workspace file
+ *
+ * - update all references to the old root path
+ * - change the project name
+ * - change target references
+ */
+export declare function updateDefaultProject(tree: Tree, schema: NormalizedSchema): void;

package/src/generators/move/lib/update-default-project.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateDefaultProject = void 0;
+const devkit_1 = require("@nx/devkit");
+/**
+ * Updates the project in the workspace file
+ *
+ * - update all references to the old root path
+ * - change the project name
+ * - change target references
+ */
+function updateDefaultProject(tree, schema) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    // update default project (if necessary)
+    if (nxJson.defaultProject && nxJson.defaultProject === schema.projectName) {
+        nxJson.defaultProject = schema.newProjectName;
+        (0, devkit_1.updateNxJson)(tree, nxJson);
+    }
+}
+exports.updateDefaultProject = updateDefaultProject;

package/src/generators/move/lib/update-eslint-config.d.ts

@@ -0,0 +1,8 @@
+import { ProjectConfiguration, Tree } from '@nx/devkit';
+import { NormalizedSchema } from '../schema';
+/**
+ * Update the .eslintrc file of the project if it exists.
+ *
+ * @param schema The options provided to the schematic
+ */
+export declare function updateEslintConfig(tree: Tree, schema: NormalizedSchema, project: ProjectConfiguration): void;

package/src/generators/move/lib/update-eslint-config.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateEslintConfig = void 0;
+const devkit_1 = require("@nx/devkit");
+/**
+ * Update the .eslintrc file of the project if it exists.
+ *
+ * @param schema The options provided to the schematic
+ */
+function updateEslintConfig(tree, schema, project) {
+    // if there is no suitable eslint config, we don't need to do anything
+    if (!tree.exists('.eslintrc.json') &&
+        !tree.exists('eslint.config.js') &&
+        !tree.exists('.eslintrc.base.json') &&
+        !tree.exists('eslint.base.config.js')) {
+        return;
+    }
+    try {
+        const { updateRelativePathsInConfig,
+        // nx-ignore-next-line
+         } = require('@nx/eslint/src/generators/utils/eslint-file');
+        updateRelativePathsInConfig(tree, project.root, schema.relativeToRootDestination);
+    }
+    catch {
+        devkit_1.output.warn({
+            title: `Could not update the eslint config file.`,
+            bodyLines: [
+                'The @nx/eslint package could not be loaded. Please update the paths in eslint config manually.',
+            ],
+        });
+    }
+}
+exports.updateEslintConfig = updateEslintConfig;

package/src/generators/move/lib/update-implicit-dependencies.d.ts

@@ -0,0 +1,6 @@
+import type { Tree } from '@nx/devkit';
+import type { NormalizedSchema } from '../schema';
+/**
+ * @param schema The options provided to the schematic
+ */
+export declare function updateImplicitDependencies(tree: Tree, schema: NormalizedSchema): void;

package/src/generators/move/lib/update-implicit-dependencies.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateImplicitDependencies = void 0;
+const devkit_1 = require("@nx/devkit");
+/**
+ * @param schema The options provided to the schematic
+ */
+function updateImplicitDependencies(tree, schema) {
+    for (const [projectName, project] of (0, devkit_1.getProjects)(tree)) {
+        if (project.implicitDependencies) {
+            const index = project.implicitDependencies.indexOf(schema.projectName);
+            if (index !== -1) {
+                project.implicitDependencies[index] = schema.newProjectName;
+                (0, devkit_1.updateProjectConfiguration)(tree, projectName, project);
+            }
+        }
+    }
+}
+exports.updateImplicitDependencies = updateImplicitDependencies;

package/src/generators/move/lib/update-imports.d.ts

@@ -0,0 +1,8 @@
+import { ProjectConfiguration, Tree } from '@nx/devkit';
+import { NormalizedSchema } from '../schema';
+/**
+ * Updates all the imports in the workspace and modifies the tsconfig appropriately.
+ *
+ * @param schema The options provided to the schematic
+ */
+export declare function updateImports(tree: Tree, schema: NormalizedSchema, project: ProjectConfiguration): void;

package/src/generators/move/lib/update-imports.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateImports = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const get_import_path_1 = require("../../../utilities/get-import-path");
+const ts_config_1 = require("../../../utilities/ts-config");
+const typescript_1 = require("../../../utilities/typescript");
+const utils_1 = require("./utils");
+let tsModule;
+/**
+ * Updates all the imports in the workspace and modifies the tsconfig appropriately.
+ *
+ * @param schema The options provided to the schematic
+ */
+function updateImports(tree, schema, project) {
+    if (project.projectType !== 'library') {
+        return;
+    }
+    const { libsDir } = (0, devkit_1.getWorkspaceLayout)(tree);
+    const projects = (0, devkit_1.getProjects)(tree);
+    // use the source root to find the from location
+    // this attempts to account for libs that have been created with --importPath
+    const tsConfigPath = (0, ts_config_1.getRootTsConfigPathInTree)(tree);
+    let tsConfig;
+    let mainEntryPointImportPath;
+    let secondaryEntryPointImportPaths;
+    if (tree.exists(tsConfigPath)) {
+        tsConfig = (0, devkit_1.readJson)(tree, tsConfigPath);
+        const sourceRoot = project.sourceRoot ?? (0, devkit_1.joinPathFragments)(project.root, 'src');
+        mainEntryPointImportPath = Object.keys(tsConfig.compilerOptions?.paths ?? {}).find((path) => tsConfig.compilerOptions.paths[path].some((x) => x.startsWith(ensureTrailingSlash(sourceRoot))));
+        secondaryEntryPointImportPaths = Object.keys(tsConfig.compilerOptions?.paths ?? {}).filter((path) => tsConfig.compilerOptions.paths[path].some((x) => x.startsWith(ensureTrailingSlash(project.root)) &&
+            !x.startsWith(ensureTrailingSlash(sourceRoot))));
+    }
+    mainEntryPointImportPath ??= (0, utils_1.normalizePathSlashes)((0, get_import_path_1.getImportPath)(tree, project.root.slice(libsDir.length).replace(/^\/|\\/, '')));
+    const projectRefs = [
+        {
+            from: mainEntryPointImportPath,
+            to: schema.importPath,
+        },
+        ...secondaryEntryPointImportPaths.map((p) => ({
+            from: p,
+            // if the import path doesn't start with the main entry point import path,
+            // it's a custom import path we don't know how to update the name, we keep
+            // it as-is, but we'll update the path it points to
+            to: schema.importPath && p.startsWith(mainEntryPointImportPath)
+                ? p.replace(mainEntryPointImportPath, schema.importPath)
+                : null,
+        })),
+    ];
+    for (const projectRef of projectRefs) {
+        if (schema.updateImportPath && projectRef.to) {
+            const replaceProjectRef = new RegExp(projectRef.from, 'g');
+            for (const [name, definition] of Array.from(projects.entries())) {
+                if (name === schema.projectName) {
+                    continue;
+                }
+                (0, devkit_1.visitNotIgnoredFiles)(tree, definition.root, (file) => {
+                    const contents = tree.read(file, 'utf-8');
+                    replaceProjectRef.lastIndex = 0;
+                    if (!replaceProjectRef.test(contents)) {
+                        return;
+                    }
+                    updateImportPaths(tree, file, projectRef.from, projectRef.to);
+                });
+            }
+        }
+        const projectRoot = {
+            from: project.root,
+            to: schema.relativeToRootDestination,
+        };
+        if (tsConfig) {
+            const path = tsConfig.compilerOptions.paths[projectRef.from];
+            if (!path) {
+                throw new Error([
+                    `unable to find "${projectRef.from}" in`,
+                    `${tsConfigPath} compilerOptions.paths`,
+                ].join(' '));
+            }
+            const updatedPath = path.map((x) => (0, devkit_1.joinPathFragments)(projectRoot.to, (0, path_1.relative)(projectRoot.from, x)));
+            if (schema.updateImportPath && projectRef.to) {
+                tsConfig.compilerOptions.paths[projectRef.to] = updatedPath;
+                if (projectRef.from !== projectRef.to) {
+                    delete tsConfig.compilerOptions.paths[projectRef.from];
+                }
+            }
+            else {
+                tsConfig.compilerOptions.paths[projectRef.from] = updatedPath;
+            }
+        }
+        (0, devkit_1.writeJson)(tree, tsConfigPath, tsConfig);
+    }
+}
+exports.updateImports = updateImports;
+function ensureTrailingSlash(path) {
+    return path.endsWith('/') ? path : `${path}/`;
+}
+/**
+ * Changes imports in a file from one import to another
+ */
+function updateImportPaths(tree, path, from, to) {
+    if (!tsModule) {
+        tsModule = (0, typescript_1.ensureTypescript)();
+    }
+    const contents = tree.read(path, 'utf-8');
+    const sourceFile = tsModule.createSourceFile(path, contents, tsModule.ScriptTarget.Latest, true);
+    // Apply changes on the various types of imports
+    const newContents = (0, devkit_1.applyChangesToString)(contents, [
+        ...updateImportDeclarations(sourceFile, from, to),
+        ...updateDynamicImports(sourceFile, from, to),
+    ]);
+    tree.write(path, newContents);
+}
+/**
+ * Update the module specifiers on static imports
+ */
+function updateImportDeclarations(sourceFile, from, to) {
+    if (!tsModule) {
+        tsModule = (0, typescript_1.ensureTypescript)();
+    }
+    const importDecls = (0, ts_config_1.findNodes)(sourceFile, [
+        tsModule.SyntaxKind.ImportDeclaration,
+        tsModule.SyntaxKind.ExportDeclaration,
+    ]);
+    const changes = [];
+    for (const { moduleSpecifier } of importDecls) {
+        if (tsModule.isStringLiteral(moduleSpecifier)) {
+            changes.push(...updateModuleSpecifier(moduleSpecifier, from, to));
+        }
+    }
+    return changes;
+}
+/**
+ * Update the module specifiers on dynamic imports and require statements
+ */
+function updateDynamicImports(sourceFile, from, to) {
+    if (!tsModule) {
+        tsModule = (0, typescript_1.ensureTypescript)();
+    }
+    const expressions = (0, ts_config_1.findNodes)(sourceFile, tsModule.SyntaxKind.CallExpression);
+    const changes = [];
+    for (const { expression, arguments: args } of expressions) {
+        const moduleSpecifier = args[0];
+        // handle dynamic import statements
+        if (expression.kind === tsModule.SyntaxKind.ImportKeyword &&
+            moduleSpecifier &&
+            tsModule.isStringLiteral(moduleSpecifier)) {
+            changes.push(...updateModuleSpecifier(moduleSpecifier, from, to));
+        }
+        // handle require statements
+        if (tsModule.isIdentifier(expression) &&
+            expression.text === 'require' &&
+            moduleSpecifier &&
+            tsModule.isStringLiteral(moduleSpecifier)) {
+            changes.push(...updateModuleSpecifier(moduleSpecifier, from, to));
+        }
+    }
+    return changes;
+}
+/**
+ * Replace the old module specifier with a the new path
+ */
+function updateModuleSpecifier(moduleSpecifier, from, to) {
+    if (moduleSpecifier.text === from ||
+        moduleSpecifier.text.startsWith(`${from}/`)) {
+        return [
+            {
+                type: devkit_1.ChangeType.Delete,
+                start: moduleSpecifier.getStart() + 1,
+                length: moduleSpecifier.text.length,
+            },
+            {
+                type: devkit_1.ChangeType.Insert,
+                index: moduleSpecifier.getStart() + 1,
+                text: moduleSpecifier.text.replace(new RegExp(from, 'g'), to),
+            },
+        ];
+    }
+    else {
+        return [];
+    }
+}

package/src/generators/move/lib/update-jest-config.d.ts

@@ -0,0 +1,10 @@
+import { ProjectConfiguration, Tree } from '@nx/devkit';
+import { NormalizedSchema } from '../schema';
+/**
+ * Updates the project name and coverage folder in the jest.config.js if it exists
+ *
+ * (assume relative paths have been updated previously)
+ *
+ * @param schema The options provided to the schematic
+ */
+export declare function updateJestConfig(tree: Tree, schema: NormalizedSchema, project: ProjectConfiguration): void;