@nx/devkit 0.0.0-pr-31222-862e973 → 0.0.0-pr-31313-387cdca

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

@@ -1,157 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.determineProjectNameAndRootOptions = determineProjectNameAndRootOptions;
-exports.setCwd = setCwd;
+exports.resolveImportPath = resolveImportPath;
+exports.ensureRootProjectName = ensureRootProjectName;
 const enquirer_1 = require("enquirer");
-const path_1 = require("path");
-const get_workspace_layout_1 = require("../utils/get-workspace-layout");
-const names_1 = require("../utils/names");
 const devkit_exports_1 = require("nx/src/devkit-exports");
+const path_1 = require("path");
 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,
-    };
-}
-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) {
-    devkit_exports_1.logger.warn((0, devkit_exports_1.stripIndents) `
-    In Nx 20, 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
-        ? (0, devkit_exports_1.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) {
-            devkit_exports_1.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) {
+    // root projects must provide name option
+    if (options.directory === '.' && !options.name) {
+        throw new Error(`When generating a root project, you must also specify the name option.`);
+    }
+    const directory = (0, devkit_exports_1.normalizePath)(options.directory);
+    const name = options.name ??
+        directory.match(/(@[^@/]+(\/[^@/]+)+)/)?.[1] ??
+        directory.substring(directory.lastIndexOf('/') + 1);
+    validateOptions(options.name, name, options.directory);
     let projectSimpleName;
     let projectFileName;
-    if (options.name.startsWith('@')) {
-        const [_scope, ...rest] = options.name.split('/');
+    if (name.startsWith('@')) {
+        const [_scope, ...rest] = name.split('/');
         projectFileName = rest.join('-');
         projectSimpleName = rest.pop();
     }
     else {
-        projectSimpleName = options.name;
-        projectFileName = options.name;
+        projectSimpleName = name;
+        projectFileName = name;
     }
     let projectRoot;
     const relativeCwd = getRelativeCwd();
-    if (options.directory) {
+    if (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;
+        if (directory === relativeCwd || directory.startsWith(`${relativeCwd}/`)) {
+            projectRoot = directory;
         }
         else {
-            projectRoot = (0, devkit_exports_1.joinPathFragments)(relativeCwd, options.directory);
+            projectRoot = (0, devkit_exports_1.joinPathFragments)(relativeCwd, directory);
         }
     }
     else if (options.rootProject) {
@@ -160,29 +44,16 @@ function getAsProvidedOptions(tree, options) {
     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 = (0, devkit_exports_1.joinPathFragments)(relativeCwd, options.name);
+        if (!relativeCwd.endsWith(name)) {
+            projectRoot = (0, devkit_exports_1.joinPathFragments)(relativeCwd, 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 === '.'
-                        ? (0, devkit_exports_1.readJson)(tree, 'package.json').name ??
-                            getImportPath(npmScope, options.name)
-                        : getImportPath(npmScope, options.name);
-            }
-        }
+    if (projectRoot.startsWith('..')) {
+        throw new Error(`The resolved project root "${projectRoot}" is outside of the workspace root "${devkit_exports_1.workspaceRoot}".`);
     }
+    const importPath = options.importPath ?? resolveImportPath(tree, name, projectRoot);
     return {
-        projectName: options.name,
+        projectName: name,
         names: {
             projectSimpleName,
             projectFileName,
@@ -191,53 +62,52 @@ function getAsProvidedOptions(tree, options) {
         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 = (0, devkit_exports_1.joinPathFragments)(layoutDirectory, projectRoot);
-    }
+function resolveImportPath(tree, projectName, projectRoot) {
     let importPath;
-    if (options.projectType === 'library') {
-        importPath = options.importPath;
-        if (!importPath) {
-            const npmScope = getNpmScope(tree);
-            importPath =
-                projectRoot === '.'
-                    ? (0, devkit_exports_1.readJson)(tree, 'package.json').name ??
-                        getImportPath(npmScope, projectName)
-                    : getImportPath(npmScope, projectDirectoryWithoutLayout);
+    if (projectName.startsWith('@')) {
+        importPath = projectName;
+    }
+    else {
+        const npmScope = getNpmScope(tree);
+        importPath =
+            projectRoot === '.'
+                ? (0, devkit_exports_1.readJson)(tree, 'package.json').name ??
+                    getImportPath(npmScope, projectName)
+                : getImportPath(npmScope, projectName);
+    }
+    return importPath;
+}
+async function ensureRootProjectName(options, projectType) {
+    if (!options.name && options.directory === '.' && getRelativeCwd() === '') {
+        const result = await (0, enquirer_1.prompt)({
+            type: 'input',
+            name: 'name',
+            message: `What do you want to name the ${projectType}?`,
+        });
+        options.name = result.name;
+    }
+}
+function validateOptions(providedName, derivedName, directory) {
+    /**
+     * The provided name and the derived name from the provided directory must match one of two cases:
+     *
+     * 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 (providedName) {
+        if (!validationRegex.test(providedName)) {
+            throw new Error(`The name should match the pattern "${pattern}". The provided value "${providedName}" does not match.`);
         }
     }
-    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;
+    else if (!validationRegex.test(derivedName)) {
+        throw new Error(`The derived name from the provided directory should match the pattern "${pattern}". The derived name "${derivedName}" from the provided value "${directory}" does not match.`);
     }
-    return { projectDirectory, layoutDirectory };
 }
 function getImportPath(npmScope, name) {
     return npmScope ? `${npmScope === '@' ? '' : '@'}${npmScope}/${name}` : name;
@@ -248,9 +118,6 @@ function getNpmScope(tree) {
         : { 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()`
@@ -265,32 +132,3 @@ function getCwd() {
 function getRelativeCwd() {
     return (0, devkit_exports_1.normalizePath)((0, path_1.relative)(devkit_exports_1.workspaceRoot, getCwd())).replace(/\/$/, '');
 }
-/**
- * Function for setting cwd during testing
- */
-function setCwd(path) {
-    process.env.INIT_CWD = (0, path_1.join)(devkit_exports_1.workspaceRoot, path);
-}
-function parseNameForAsProvided(rawName) {
-    const directory = (0, devkit_exports_1.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 = (0, devkit_exports_1.normalizePath)(rawName).split('/');
-    const name = parsedName.pop();
-    const directory = parsedName.length ? parsedName.join('/') : undefined;
-    return { name, directory };
-}

package/src/generators/prompt.d.ts

@@ -0,0 +1,2 @@
+import { prompt } from 'enquirer';
+export declare function promptWhenInteractive<T>(questions: Parameters<typeof prompt>[0], defaultValue: T): Promise<T>;

package/src/generators/prompt.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptWhenInteractive = promptWhenInteractive;
+const enquirer_1 = require("enquirer");
+const devkit_internals_1 = require("nx/src/devkit-internals");
+async function promptWhenInteractive(questions, defaultValue) {
+    if (!isInteractive()) {
+        return defaultValue;
+    }
+    return await (0, enquirer_1.prompt)(questions);
+}
+function isInteractive() {
+    return (!(0, devkit_internals_1.isCI)() && !!process.stdout.isTTY && process.env.NX_INTERACTIVE === 'true');
+}

package/src/generators/target-defaults-utils.js

@@ -46,7 +46,7 @@ async function addE2eCiTargetDefaults(tree, e2ePlugin, buildTarget, pathToE2ECon
     const ciTargetName = typeof foundPluginForApplication === 'string'
         ? 'e2e-ci'
         : foundPluginForApplication.options?.ciTargetName ?? 'e2e-ci';
-    const ciTargetNameGlob = `${ciTargetName}--**/*`;
+    const ciTargetNameGlob = `${ciTargetName}--**/**`;
     nxJson.targetDefaults ??= {};
     const e2eCiTargetDefaults = nxJson.targetDefaults[ciTargetNameGlob];
     if (!e2eCiTargetDefaults) {

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

@@ -3,21 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.updateTsConfigsToJs = updateTsConfigsToJs;
 const devkit_exports_1 = require("nx/src/devkit-exports");
 function updateTsConfigsToJs(tree, options) {
-    let updateConfigPath;
+    let updateConfigPath = null;
     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`);
-    };
     (0, devkit_exports_1.updateJson)(tree, paths.tsConfig, (json) => {
         if (json.compilerOptions) {
             json.compilerOptions.allowJs = true;
@@ -27,21 +18,25 @@ function updateTsConfigsToJs(tree, options) {
         }
         return json;
     });
-    const projectType = getProjectType(tree);
-    if (projectType === 'library') {
+    if (tree.exists(paths.tsConfigLib)) {
         updateConfigPath = paths.tsConfigLib;
     }
-    if (projectType === 'application') {
+    if (tree.exists(paths.tsConfigApp)) {
         updateConfigPath = paths.tsConfigApp;
     }
-    (0, devkit_exports_1.updateJson)(tree, updateConfigPath, (json) => {
-        json.include = uniq([...json.include, 'src/**/*.js']);
-        json.exclude = uniq([
-            ...json.exclude,
-            'src/**/*.spec.js',
-            'src/**/*.test.js',
-        ]);
-        return json;
-    });
+    if (updateConfigPath) {
+        (0, devkit_exports_1.updateJson)(tree, updateConfigPath, (json) => {
+            json.include = uniq([...(json.include ?? []), 'src/**/*.js']);
+            json.exclude = uniq([
+                ...(json.exclude ?? []),
+                'src/**/*.spec.js',
+                'src/**/*.test.js',
+            ]);
+            return json;
+        });
+    }
+    else {
+        throw new Error(`project is missing tsconfig.lib.json or tsconfig.app.json`);
+    }
 }
 const uniq = (value) => [...new Set(value)];

package/src/tasks/install-packages-task.js

@@ -27,7 +27,7 @@ function installPackagesTask(tree, alwaysRun = false, cwd = '', packageManager =
         const execSyncOptions = {
             cwd: (0, path_1.join)(tree.root, cwd),
             stdio: process.env.NX_GENERATE_QUIET === 'true' ? 'ignore' : 'inherit',
-            windowsHide: true,
+            windowsHide: false,
         };
         // ensure local registry from process is not interfering with the install
         // when we start the process from temp folder the local registry would override the custom registry

package/src/utils/add-plugin.js

@@ -55,8 +55,12 @@ async function _addPluginInternal(tree, graph, pluginName, pluginFactory, option
             }
             catch (e) {
                 // Errors are okay for this because we're only running 1 plugin
-                if (e instanceof devkit_internals_1.ProjectConfigurationsError) {
+                if ((0, devkit_internals_1.isProjectConfigurationsError)(e)) {
                     projConfigs = e.partialProjectConfigurationsResult;
+                    // ignore errors from projects with no name
+                    if (!e.errors.every(devkit_internals_1.isProjectsWithNoNameError)) {
+                        throw e;
+                    }
                 }
                 else {
                     throw e;
@@ -89,8 +93,12 @@ async function _addPluginInternal(tree, graph, pluginName, pluginFactory, option
         }
         catch (e) {
             // Errors are okay for this because we're only running 1 plugin
-            if (e instanceof devkit_internals_1.ProjectConfigurationsError) {
+            if ((0, devkit_internals_1.isProjectConfigurationsError)(e)) {
                 projConfigs = e.partialProjectConfigurationsResult;
+                // ignore errors from projects with no name
+                if (!e.errors.every(devkit_internals_1.isProjectsWithNoNameError)) {
+                    throw e;
+                }
             }
             else {
                 throw e;
@@ -129,7 +137,8 @@ function processProject(tree, projectRoot, projectConfiguration) {
     if (!targetCommands.length) {
         return;
     }
-    const replacedTargets = new Set();
+    let hasChanges = false;
+    targetCommands.sort((a, b) => b.command.split(/\s/).length - a.command.split(/\s/).length);
     for (const targetCommand of targetCommands) {
         const { command, target, configuration } = targetCommand;
         const targetCommandRegex = new RegExp(`(?<=^|&)((?: )*(?:[^&\\r\\n\\s]+ )*)(${command})((?: [^&\\r\\n\\s]+)*(?: )*)(?=$|&)`, 'g');
@@ -140,7 +149,7 @@ function processProject(tree, projectRoot, projectConfiguration) {
                 packageJson.scripts[scriptName] = script.replace(targetCommandRegex, configuration
                     ? `$1nx ${target} --configuration=${configuration}$3`
                     : `$1nx ${target}$3`);
-                replacedTargets.add(target);
+                hasChanges = true;
             }
             else {
                 /**
@@ -196,23 +205,26 @@ function processProject(tree, projectRoot, projectConfiguration) {
                     }
                     if (!hasArgsWithDifferentValues && !scriptHasExtraArgs) {
                         // they are the same, replace with the command removing the args
-                        packageJson.scripts[scriptName] = packageJson.scripts[scriptName].replace(match, match.replace(commandRegex, configuration
+                        const script = packageJson.scripts[scriptName];
+                        packageJson.scripts[scriptName] = script.replace(match, match.replace(commandRegex, configuration
                             ? `$1nx ${target} --configuration=${configuration}$4`
                             : `$1nx ${target}$4`));
-                        replacedTargets.add(target);
+                        hasChanges = true;
                     }
                     else {
                         // there are different args or the script has extra args, replace with the command leaving the args
                         packageJson.scripts[scriptName] = packageJson.scripts[scriptName].replace(match, match.replace(commandRegex, configuration
                             ? `$1nx ${target} --configuration=${configuration}$3`
                             : `$1nx ${target}$3`));
-                        replacedTargets.add(target);
+                        hasChanges = true;
                     }
                 }
             }
         }
     }
-    (0, devkit_exports_1.writeJson)(tree, packageJsonPath, packageJson);
+    if (hasChanges) {
+        (0, devkit_exports_1.writeJson)(tree, packageJsonPath, packageJson);
+    }
 }
 function getInferredTargetCommands(project) {
     const targetCommands = [];

package/src/utils/async-iterable/create-async-iterable.d.ts

@@ -2,5 +2,6 @@ export interface AsyncPushCallbacks<T> {
     next: (value: T) => void;
     done: () => void;
     error: (err: unknown) => void;
+    registerCleanup?: (cb: () => void | Promise<void>) => void;
 }
 export declare function createAsyncIterable<T = unknown>(listener: (ls: AsyncPushCallbacks<T>) => void): AsyncIterable<T>;

package/src/utils/async-iterable/create-async-iterable.js

@@ -4,6 +4,7 @@ exports.createAsyncIterable = createAsyncIterable;
 function createAsyncIterable(listener) {
     let done = false;
     let error = null;
+    let cleanup;
     const pushQueue = [];
     const pullQueue = [];
     return {
@@ -33,6 +34,9 @@ function createAsyncIterable(listener) {
                     }
                     done = true;
                 },
+                registerCleanup: (cb) => {
+                    cleanup = cb;
+                },
             });
             return {
                 next() {
@@ -51,6 +55,12 @@ function createAsyncIterable(listener) {
                         }
                     });
                 },
+                async return() {
+                    if (cleanup) {
+                        await cleanup();
+                    }
+                    return { value: undefined, done: true };
+                },
             };
         },
     };

package/src/utils/binary-extensions.js

@@ -191,6 +191,7 @@ const binaryExtensions = new Set([
     '.resources',
     '.rgb',
     '.rip',
+    '.riv',
     '.rlc',
     '.rmf',
     '.rmvb',

package/src/utils/calculate-hash-for-create-nodes.d.ts

@@ -1,2 +1,3 @@
 import { CreateNodesContext, CreateNodesContextV2 } from 'nx/src/devkit-exports';
 export declare function calculateHashForCreateNodes(projectRoot: string, options: object, context: CreateNodesContext | CreateNodesContextV2, additionalGlobs?: string[]): Promise<string>;
+export declare function calculateHashesForCreateNodes(projectRoots: string[], options: object, context: CreateNodesContext | CreateNodesContextV2, additionalGlobs?: string[][]): Promise<string[]>;

package/src/utils/calculate-hash-for-create-nodes.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.calculateHashForCreateNodes = calculateHashForCreateNodes;
+exports.calculateHashesForCreateNodes = calculateHashesForCreateNodes;
 const path_1 = require("path");
 const devkit_exports_1 = require("nx/src/devkit-exports");
 const devkit_internals_1 = require("nx/src/devkit-internals");
@@ -13,3 +14,15 @@ async function calculateHashForCreateNodes(projectRoot, options, context, additi
         (0, devkit_internals_1.hashObject)(options),
     ]);
 }
+async function calculateHashesForCreateNodes(projectRoots, options, context, additionalGlobs = []) {
+    if (additionalGlobs.length &&
+        additionalGlobs.length !== projectRoots.length) {
+        throw new Error('If additionalGlobs is provided, it must be the same length as projectRoots');
+    }
+    return (0, devkit_internals_1.hashMultiGlobWithWorkspaceContext)(context.workspaceRoot, projectRoots.map((projectRoot, idx) => [
+        (0, path_1.join)(projectRoot, '**/*'),
+        ...(additionalGlobs.length ? additionalGlobs[idx] : []),
+    ])).then((hashes) => {
+        return hashes.map((hash) => (0, devkit_exports_1.hashArray)([hash, (0, devkit_internals_1.hashObject)(options)]));
+    });
+}