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

package/src/generators/project-name-and-root-utils.js

@@ -0,0 +1,298 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setCwd = exports.determineProjectNameAndRootOptions = void 0;
+const enquirer_1 = require("enquirer");
+const path_1 = require("path");
+const nx_1 = require("../../nx");
+const get_workspace_layout_1 = require("../utils/get-workspace-layout");
+const names_1 = require("../utils/names");
+const { joinPathFragments, logger, normalizePath, output, readJson, stripIndents, workspaceRoot, } = (0, nx_1.requireNx)();
+async function determineProjectNameAndRootOptions(tree, options) {
+    if (!options.projectNameAndRootFormat &&
+        (process.env.NX_INTERACTIVE !== 'true' || !isTTY())) {
+        options.projectNameAndRootFormat = 'derived';
+    }
+    validateName(options.name, options.projectNameAndRootFormat);
+    const formats = getProjectNameAndRootFormats(tree, options);
+    const format = options.projectNameAndRootFormat ?? (await determineFormat(formats));
+    if (format === 'derived' && options.callingGenerator) {
+        logDeprecationMessage(options.callingGenerator, formats);
+    }
+    return {
+        ...formats[format],
+        projectNameAndRootFormat: format,
+    };
+}
+exports.determineProjectNameAndRootOptions = determineProjectNameAndRootOptions;
+function validateName(name, projectNameAndRootFormat) {
+    if (projectNameAndRootFormat === 'derived' && name.startsWith('@')) {
+        throw new Error(`The 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 pattern = '(?:^@[a-zA-Z0-9-*~][a-zA-Z0-9-*._~]*\\/[a-zA-Z0-9-~][a-zA-Z0-9-._~]*|^[a-zA-Z][^:]*)$';
+    const validationRegex = new RegExp(pattern);
+    if (!validationRegex.test(name)) {
+        throw new Error(`The project name should match the pattern "${pattern}". The provided value "${name}" does not match.`);
+    }
+}
+function logDeprecationMessage(callingGenerator, formats) {
+    logger.warn(stripIndents `
+    In Nx 19, generating projects will no longer derive the name and root.
+    Please provide the exact project name and root in the future.
+    Example: nx g ${callingGenerator} ${formats['derived'].projectName} --directory ${formats['derived'].projectRoot}
+  `);
+}
+async function determineFormat(formats) {
+    if (!formats.derived) {
+        return 'as-provided';
+    }
+    const asProvidedDescription = `As provided:
+    Name: ${formats['as-provided'].projectName}
+    Root: ${formats['as-provided'].projectRoot}`;
+    const asProvidedSelectedValue = `${formats['as-provided'].projectName} @ ${formats['as-provided'].projectRoot}`;
+    const derivedDescription = `Derived:
+    Name: ${formats['derived'].projectName}
+    Root: ${formats['derived'].projectRoot}`;
+    const derivedSelectedValue = `${formats['derived'].projectName} @ ${formats['derived'].projectRoot}`;
+    if (asProvidedSelectedValue === derivedSelectedValue) {
+        return 'as-provided';
+    }
+    const result = await (0, enquirer_1.prompt)({
+        type: 'select',
+        name: 'format',
+        message: 'What should be the project name and where should it be generated?',
+        choices: [
+            {
+                message: asProvidedDescription,
+                name: asProvidedSelectedValue,
+            },
+            {
+                message: derivedDescription,
+                name: derivedSelectedValue,
+            },
+        ],
+        initial: 0,
+    }).then(({ format }) => format === asProvidedSelectedValue ? 'as-provided' : 'derived');
+    return result;
+}
+function getProjectNameAndRootFormats(tree, options) {
+    const directory = options.directory
+        ? normalizePath(options.directory.replace(/^\.?\//, ''))
+        : undefined;
+    const { name: asProvidedParsedName, directory: asProvidedParsedDirectory } = parseNameForAsProvided(options.name);
+    if (asProvidedParsedDirectory && directory) {
+        throw new Error(`You can't specify both a directory (${options.directory}) and a name with a directory path (${options.name}). ` +
+            `Please specify either a directory or a name with a directory path.`);
+    }
+    const asProvidedOptions = getAsProvidedOptions(tree, {
+        ...options,
+        directory: directory ?? asProvidedParsedDirectory,
+        name: asProvidedParsedName,
+    });
+    if (options.projectNameAndRootFormat === 'as-provided') {
+        return {
+            'as-provided': asProvidedOptions,
+            derived: undefined,
+        };
+    }
+    if (asProvidedOptions.projectName.startsWith('@')) {
+        if (!options.projectNameAndRootFormat) {
+            output.warn({
+                title: `The provided name "${options.name}" contains a scoped project name and this is not supported by the "${options.callingGenerator}" when using the "derived" format.`,
+                bodyLines: [
+                    `The generator will try to generate the project "${asProvidedOptions.projectName}" using the "as-provided" format at "${asProvidedOptions.projectRoot}".`,
+                ],
+            });
+            return {
+                'as-provided': asProvidedOptions,
+                derived: undefined,
+            };
+        }
+        throw new Error(`The provided name "${options.name}" contains a scoped project name and this is not supported by the "${options.callingGenerator}" when using the "derived" format. ` +
+            `Please provide a name without "@" or use the "as-provided" format.`);
+    }
+    const { name: derivedParsedName, directory: derivedParsedDirectory } = parseNameForDerived(options.name);
+    const derivedOptions = getDerivedOptions(tree, {
+        ...options,
+        directory: directory ?? derivedParsedDirectory,
+        name: derivedParsedName,
+    });
+    return {
+        'as-provided': asProvidedOptions,
+        derived: derivedOptions,
+    };
+}
+function getAsProvidedOptions(tree, options) {
+    let projectSimpleName;
+    let projectFileName;
+    if (options.name.startsWith('@')) {
+        const [_scope, ...rest] = options.name.split('/');
+        projectFileName = rest.join('-');
+        projectSimpleName = rest.pop();
+    }
+    else {
+        projectSimpleName = options.name;
+        projectFileName = options.name;
+    }
+    let projectRoot;
+    const relativeCwd = getRelativeCwd();
+    if (options.directory) {
+        // append the directory to the current working directory if it doesn't start with it
+        if (options.directory === relativeCwd ||
+            options.directory.startsWith(`${relativeCwd}/`)) {
+            projectRoot = options.directory;
+        }
+        else {
+            projectRoot = joinPathFragments(relativeCwd, options.directory);
+        }
+    }
+    else if (options.rootProject) {
+        projectRoot = '.';
+    }
+    else {
+        projectRoot = relativeCwd;
+        // append the project name to the current working directory if it doesn't end with it
+        if (!relativeCwd.endsWith(options.name)) {
+            projectRoot = joinPathFragments(relativeCwd, options.name);
+        }
+    }
+    let importPath = undefined;
+    if (options.projectType === 'library') {
+        importPath = options.importPath;
+        if (!importPath) {
+            if (options.name.startsWith('@')) {
+                importPath = options.name;
+            }
+            else {
+                const npmScope = getNpmScope(tree);
+                importPath =
+                    projectRoot === '.'
+                        ? readJson(tree, 'package.json').name ??
+                            getImportPath(npmScope, options.name)
+                        : getImportPath(npmScope, options.name);
+            }
+        }
+    }
+    return {
+        projectName: options.name,
+        names: {
+            projectSimpleName,
+            projectFileName,
+        },
+        importPath,
+        projectRoot,
+    };
+}
+function getDerivedOptions(tree, options) {
+    const name = (0, names_1.names)(options.name).fileName;
+    let { projectDirectory, layoutDirectory } = getDirectories(tree, options.directory, options.projectType);
+    const projectDirectoryWithoutLayout = projectDirectory
+        ? `${(0, names_1.names)(projectDirectory).fileName}/${name}`
+        : options.rootProject
+            ? '.'
+            : name;
+    // the project name uses the directory without the layout directory
+    const projectName = projectDirectoryWithoutLayout === '.'
+        ? name
+        : projectDirectoryWithoutLayout.replace(/\//g, '-');
+    const projectSimpleName = name;
+    let projectRoot = projectDirectoryWithoutLayout;
+    if (projectDirectoryWithoutLayout !== '.') {
+        // prepend the layout directory
+        projectRoot = joinPathFragments(layoutDirectory, projectRoot);
+    }
+    let importPath;
+    if (options.projectType === 'library') {
+        importPath = options.importPath;
+        if (!importPath) {
+            const npmScope = getNpmScope(tree);
+            importPath =
+                projectRoot === '.'
+                    ? readJson(tree, 'package.json').name ??
+                        getImportPath(npmScope, projectName)
+                    : getImportPath(npmScope, projectDirectoryWithoutLayout);
+        }
+    }
+    return {
+        projectName,
+        names: {
+            projectSimpleName,
+            projectFileName: projectName,
+        },
+        importPath,
+        projectRoot,
+    };
+}
+function getDirectories(tree, directory, projectType) {
+    let { projectDirectory, layoutDirectory } = (0, get_workspace_layout_1.extractLayoutDirectory)(directory);
+    if (!layoutDirectory) {
+        const { appsDir, libsDir } = (0, get_workspace_layout_1.getWorkspaceLayout)(tree);
+        layoutDirectory = projectType === 'application' ? appsDir : libsDir;
+    }
+    return { projectDirectory, layoutDirectory };
+}
+function getImportPath(npmScope, name) {
+    return npmScope ? `${npmScope === '@' ? '' : '@'}${npmScope}/${name}` : name;
+}
+function getNpmScope(tree) {
+    const { name } = tree.exists('package.json')
+        ? readJson(tree, 'package.json')
+        : { name: null };
+    return name?.startsWith('@') ? name.split('/')[0].substring(1) : undefined;
+}
+function isTTY() {
+    return !!process.stdout.isTTY && process.env['CI'] !== 'true';
+}
+/**
+ * When running a script with the package manager (e.g. `npm run`), the package manager will
+ * traverse the directory tree upwards until it finds a `package.json` and will set `process.cwd()`
+ * to the folder where it found it. The actual working directory is stored in the INIT_CWD
+ * environment variable (see here: https://docs.npmjs.com/cli/v9/commands/npm-run-script#description).
+ */
+function getCwd() {
+    return process.env.INIT_CWD?.startsWith(workspaceRoot)
+        ? process.env.INIT_CWD
+        : process.cwd();
+}
+function getRelativeCwd() {
+    return normalizePath((0, path_1.relative)(workspaceRoot, getCwd())).replace(/\/$/, '');
+}
+/**
+ * Function for setting cwd during testing
+ */
+function setCwd(path) {
+    process.env.INIT_CWD = (0, path_1.join)(workspaceRoot, path);
+}
+exports.setCwd = setCwd;
+function parseNameForAsProvided(rawName) {
+    const directory = normalizePath(rawName);
+    if (rawName.includes('@')) {
+        const index = directory.lastIndexOf('@');
+        if (index === 0) {
+            return { name: rawName, directory: undefined };
+        }
+        const name = directory.substring(index);
+        return { name, directory };
+    }
+    if (rawName.includes('/')) {
+        const index = directory.lastIndexOf('/');
+        const name = directory.substring(index + 1);
+        return { name, directory };
+    }
+    return { name: rawName, directory: undefined };
+}
+function parseNameForDerived(rawName) {
+    const parsedName = normalizePath(rawName).split('/');
+    const name = parsedName.pop();
+    const directory = parsedName.length ? parsedName.join('/') : undefined;
+    return { name, directory };
+}

package/src/generators/run-tasks-in-serial.d.ts

@@ -0,0 +1,7 @@
+import type { GeneratorCallback } from 'nx/src/config/misc-interfaces';
+/**
+ * Run tasks in serial
+ *
+ * @param tasks The tasks to run in serial.
+ */
+export declare function runTasksInSerial(...tasks: GeneratorCallback[]): GeneratorCallback;

package/src/generators/run-tasks-in-serial.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runTasksInSerial = void 0;
+/**
+ * Run tasks in serial
+ *
+ * @param tasks The tasks to run in serial.
+ */
+function runTasksInSerial(...tasks) {
+    return async () => {
+        for (const task of tasks) {
+            await task();
+        }
+    };
+}
+exports.runTasksInSerial = runTasksInSerial;

package/src/generators/to-js.d.ts

@@ -0,0 +1,11 @@
+import type { Tree } from 'nx/src/generators/tree';
+import type { ScriptTarget, ModuleKind } from 'typescript';
+export type ToJSOptions = {
+    target?: ScriptTarget;
+    module?: ModuleKind;
+    extension: '.js' | '.mjs' | '.cjs';
+};
+/**
+ * Rename and transpile any new typescript files created to javascript files
+ */
+export declare function toJS(tree: Tree, options?: ToJSOptions): void;

package/src/generators/to-js.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toJS = void 0;
+const versions_1 = require("../utils/versions");
+const package_json_1 = require("../utils/package-json");
+/**
+ * Rename and transpile any new typescript files created to javascript files
+ */
+function toJS(tree, options) {
+    const { JsxEmit, ScriptTarget, transpile, ModuleKind } = (0, package_json_1.ensurePackage)('typescript', versions_1.typescriptVersion);
+    for (const c of tree.listChanges()) {
+        if ((c.path.endsWith('.ts') || c.path.endsWith('tsx')) &&
+            c.type === 'CREATE') {
+            tree.write(c.path, transpile(c.content.toString('utf-8'), {
+                allowJs: true,
+                jsx: JsxEmit.Preserve,
+                target: options?.target ?? ScriptTarget.ESNext,
+                module: options?.module ?? ModuleKind.ESNext,
+            }));
+            tree.rename(c.path, c.path.replace(/\.tsx?$/, options?.extension ?? '.js'));
+        }
+    }
+}
+exports.toJS = toJS;

package/src/generators/typescript/insert-import.d.ts

@@ -0,0 +1 @@
+export declare function insertImport(): void;

package/src/generators/typescript/insert-import.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.insertImport = void 0;
+function insertImport() { }
+exports.insertImport = insertImport;

package/src/generators/typescript/insert-statement.d.ts

@@ -0,0 +1 @@
+export declare function insertImport(): void;

package/src/generators/typescript/insert-statement.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.insertImport = void 0;
+function insertImport() { }
+exports.insertImport = insertImport;

package/src/generators/update-ts-configs-to-js.d.ts

@@ -0,0 +1,4 @@
+import type { Tree } from 'nx/src/generators/tree';
+export declare function updateTsConfigsToJs(tree: Tree, options: {
+    projectRoot: string;
+}): void;

package/src/generators/update-ts-configs-to-js.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateTsConfigsToJs = void 0;
+const nx_1 = require("../../nx");
+const { updateJson } = (0, nx_1.requireNx)();
+function updateTsConfigsToJs(tree, options) {
+    let updateConfigPath;
+    const paths = {
+        tsConfig: `${options.projectRoot}/tsconfig.json`,
+        tsConfigLib: `${options.projectRoot}/tsconfig.lib.json`,
+        tsConfigApp: `${options.projectRoot}/tsconfig.app.json`,
+    };
+    const getProjectType = (tree) => {
+        if (tree.exists(paths.tsConfigApp)) {
+            return 'application';
+        }
+        if (tree.exists(paths.tsConfigLib)) {
+            return 'library';
+        }
+        throw new Error(`project is missing tsconfig.lib.json or tsconfig.app.json`);
+    };
+    updateJson(tree, paths.tsConfig, (json) => {
+        if (json.compilerOptions) {
+            json.compilerOptions.allowJs = true;
+        }
+        else {
+            json.compilerOptions = { allowJs: true };
+        }
+        return json;
+    });
+    const projectType = getProjectType(tree);
+    if (projectType === 'library') {
+        updateConfigPath = paths.tsConfigLib;
+    }
+    if (projectType === 'application') {
+        updateConfigPath = paths.tsConfigApp;
+    }
+    updateJson(tree, updateConfigPath, (json) => {
+        json.include = uniq([...json.include, 'src/**/*.js']);
+        json.exclude = uniq([
+            ...json.exclude,
+            'src/**/*.spec.js',
+            'src/**/*.test.js',
+        ]);
+        return json;
+    });
+}
+exports.updateTsConfigsToJs = updateTsConfigsToJs;
+const uniq = (value) => [...new Set(value)];

package/src/generators/visit-not-ignored-files.d.ts

@@ -0,0 +1,5 @@
+import type { Tree } from 'nx/src/generators/tree';
+/**
+ * Utility to act on all files in a tree that are not ignored by git.
+ */
+export declare function visitNotIgnoredFiles(tree: Tree, dirPath: string, visitor: (path: string) => void): void;

package/src/generators/visit-not-ignored-files.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.visitNotIgnoredFiles = void 0;
+const ignore_1 = require("ignore");
+const path_1 = require("path");
+/**
+ * Utility to act on all files in a tree that are not ignored by git.
+ */
+function visitNotIgnoredFiles(tree, dirPath = tree.root, visitor) {
+    // TODO (v17): use packages/nx/src/utils/ignore.ts
+    let ig;
+    if (tree.exists('.gitignore')) {
+        ig = (0, ignore_1.default)();
+        ig.add('.git');
+        ig.add(tree.read('.gitignore', 'utf-8'));
+    }
+    if (tree.exists('.nxignore')) {
+        ig ??= (0, ignore_1.default)();
+        ig.add(tree.read('.nxignore', 'utf-8'));
+    }
+    dirPath = normalizePathRelativeToRoot(dirPath, tree.root);
+    if (dirPath !== '' && ig?.ignores(dirPath)) {
+        return;
+    }
+    for (const child of tree.children(dirPath)) {
+        const fullPath = (0, path_1.join)(dirPath, child);
+        if (ig?.ignores(fullPath)) {
+            continue;
+        }
+        if (tree.isFile(fullPath)) {
+            visitor(fullPath);
+        }
+        else {
+            visitNotIgnoredFiles(tree, fullPath, visitor);
+        }
+    }
+}
+exports.visitNotIgnoredFiles = visitNotIgnoredFiles;
+function normalizePathRelativeToRoot(path, root) {
+    return (0, path_1.relative)(root, (0, path_1.join)(root, path)).split(path_1.sep).join('/');
+}

package/src/migrations/update-16-0-0-add-nx-packages/update-16-0-0-add-nx-packages.d.ts

@@ -0,0 +1,2 @@
+import type { Tree } from 'nx/src/generators/tree';
+export default function replacePackage(tree: Tree): Promise<void>;

package/src/migrations/update-16-0-0-add-nx-packages/update-16-0-0-add-nx-packages.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const format_files_1 = require("../../generators/format-files");
+const replace_package_1 = require("../../utils/replace-package");
+async function replacePackage(tree) {
+    await (0, replace_package_1.replaceNrwlPackageWithNxPackage)(tree, '@nrwl/devkit', '@nx/devkit');
+    await (0, format_files_1.formatFiles)(tree);
+}
+exports.default = replacePackage;

package/src/migrations/update-16-9-0/migrate-mf-util-usage.d.ts

@@ -0,0 +1,4 @@
+import type { Tree } from 'nx/src/generators/tree';
+import type { GeneratorCallback } from 'nx/src/config/misc-interfaces';
+declare const _default: (tree: Tree) => Promise<GeneratorCallback | void>;
+export default _default;