@nx/rollup 23.0.0-pr.35413.460eeef → 23.0.0-rc.0

package/dist/src/migrations/update-23-0-0/remove-use-legacy-typescript-plugin.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const devkit_1 = require("@nx/devkit");
+const tsquery_1 = require("@phenomnomnominal/tsquery");
+const ROLLUP_CONFIG_NAMES = [
+    'rollup.config.cjs',
+    'rollup.config.mjs',
+    'rollup.config.js',
+    'rollup.config.ts',
+];
+const PROPERTY_NAME = 'useLegacyTypescriptPlugin';
+async function default_1(tree) {
+    const projects = (0, devkit_1.getProjects)(tree);
+    // Track whether the migration actually stripped any legacy config so we
+    // only strip the orphan devDep when it was needed (a user could have
+    // installed `rollup-plugin-typescript2` for their own custom rollup setup).
+    let anyChange = false;
+    for (const [projectName] of projects) {
+        const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, projectName);
+        let projectJsonChanged = false;
+        if (projectConfig.targets) {
+            for (const [, targetConfig] of Object.entries(projectConfig.targets)) {
+                if (targetConfig.executor !== '@nx/rollup:rollup' &&
+                    targetConfig.executor !== '@nrwl/rollup:rollup') {
+                    continue;
+                }
+                if (targetConfig.options &&
+                    'useLegacyTypescriptPlugin' in targetConfig.options) {
+                    delete targetConfig.options.useLegacyTypescriptPlugin;
+                    projectJsonChanged = true;
+                }
+                if (targetConfig.configurations) {
+                    for (const [, config] of Object.entries(targetConfig.configurations)) {
+                        if ('useLegacyTypescriptPlugin' in config) {
+                            delete config.useLegacyTypescriptPlugin;
+                            projectJsonChanged = true;
+                        }
+                    }
+                }
+            }
+        }
+        if (projectJsonChanged) {
+            (0, devkit_1.updateProjectConfiguration)(tree, projectName, projectConfig);
+            anyChange = true;
+        }
+        (0, devkit_1.visitNotIgnoredFiles)(tree, projectConfig.root, (filePath) => {
+            const basename = filePath.split('/').pop();
+            if (!ROLLUP_CONFIG_NAMES.includes(basename))
+                return;
+            if (stripFromRollupConfig(tree, filePath)) {
+                anyChange = true;
+            }
+        });
+    }
+    // Strip from nx.json targetDefaults (keyed by target name or executor name).
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    if (nxJson?.targetDefaults) {
+        const ROLLUP_EXECUTORS = ['@nx/rollup:rollup', '@nrwl/rollup:rollup'];
+        let nxJsonChanged = false;
+        for (const [targetOrExecutor, targetDefault] of Object.entries(nxJson.targetDefaults)) {
+            if (!ROLLUP_EXECUTORS.includes(targetOrExecutor) &&
+                !ROLLUP_EXECUTORS.includes(targetDefault.executor)) {
+                continue;
+            }
+            if (targetDefault.options &&
+                'useLegacyTypescriptPlugin' in targetDefault.options) {
+                delete targetDefault.options.useLegacyTypescriptPlugin;
+                nxJsonChanged = true;
+            }
+            if (targetDefault.configurations) {
+                for (const [, config] of Object.entries(targetDefault.configurations)) {
+                    if ('useLegacyTypescriptPlugin' in config) {
+                        delete config.useLegacyTypescriptPlugin;
+                        nxJsonChanged = true;
+                    }
+                }
+            }
+        }
+        if (nxJsonChanged) {
+            (0, devkit_1.updateNxJson)(tree, nxJson);
+            anyChange = true;
+        }
+    }
+    // Only strip the orphan devDep when we actually stripped a legacy config.
+    // Skipping otherwise preserves a user's own dep on rollup-plugin-typescript2.
+    if (anyChange) {
+        (0, devkit_1.removeDependenciesFromPackageJson)(tree, [], ['rollup-plugin-typescript2']);
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}
+function stripFromRollupConfig(tree, filePath) {
+    const original = tree.read(filePath, 'utf-8');
+    if (!original?.includes(PROPERTY_NAME))
+        return false;
+    // Filter by the property NAME (not any descendant Identifier) so we don't
+    // strip `{ alias: useLegacyTypescriptPlugin }` where the identifier appears as a value.
+    // Also handle shorthand `{ useLegacyTypescriptPlugin }` — strip the entry, leave
+    // the variable declaration behind (not our problem).
+    const matches = (0, tsquery_1.query)((0, tsquery_1.ast)(original), 'PropertyAssignment, ShorthandPropertyAssignment').filter((p) => p.name && p.name.text === PROPERTY_NAME);
+    if (matches.length === 0)
+        return false;
+    // Walk in reverse so each splice doesn't shift the offsets of remaining matches
+    // (a file may legitimately contain multiple withNx({...}) calls, e.g. multi-format
+    // configs returning more than one rollup options object).
+    let updated = original;
+    for (const propNode of matches.slice().reverse()) {
+        let start = propNode.getStart();
+        let end = propNode.getEnd();
+        if (updated[end] === ',')
+            end += 1;
+        // If the property occupies its own line, drop the whole line including indentation.
+        const lineStart = updated.lastIndexOf('\n', start - 1) + 1;
+        const nextNewline = updated.indexOf('\n', end);
+        const lineEnd = nextNewline === -1 ? updated.length : nextNewline + 1;
+        if (/^\s*$/.test(updated.slice(lineStart, start)) &&
+            /^\s*$/.test(updated.slice(end, lineEnd))) {
+            start = lineStart;
+            end = lineEnd;
+        }
+        updated = updated.slice(0, start) + updated.slice(end);
+    }
+    tree.write(filePath, updated);
+    return true;
+}

package/dist/src/migrations/update-23-0-0/remove-use-legacy-typescript-plugin.md

@@ -0,0 +1,100 @@
+#### Remove the `useLegacyTypescriptPlugin` Option from the `@nx/rollup:rollup` Executor
+
+Removes the deprecated `useLegacyTypescriptPlugin` option from the `@nx/rollup:rollup` executor. The legacy TypeScript plugin support has been dropped; the option no longer has any effect. The migration removes it from project configuration, target defaults in `nx.json`, and `rollup.config.*` files that pass it to `withNx`.
+
+#### Sample Code Changes
+
+Remove `useLegacyTypescriptPlugin` from the `@nx/rollup:rollup` executor options in project configuration.
+
+##### Before
+
+```json title="libs/my-lib/project.json" {8}
+{
+  "targets": {
+    "build": {
+      "executor": "@nx/rollup:rollup",
+      "options": {
+        "main": "libs/my-lib/src/index.ts",
+        "outputPath": "dist/libs/my-lib",
+        "useLegacyTypescriptPlugin": true
+      }
+    }
+  }
+}
+```
+
+##### After
+
+```json title="libs/my-lib/project.json"
+{
+  "targets": {
+    "build": {
+      "executor": "@nx/rollup:rollup",
+      "options": {
+        "main": "libs/my-lib/src/index.ts",
+        "outputPath": "dist/libs/my-lib"
+      }
+    }
+  }
+}
+```
+
+Remove `useLegacyTypescriptPlugin` from the `@nx/rollup:rollup` executor target defaults in `nx.json`.
+
+##### Before
+
+```json title="nx.json" {7}
+{
+  "targetDefaults": {
+    "@nx/rollup:rollup": {
+      "options": {
+        "outputPath": "dist/{projectRoot}",
+        "tsConfig": "{projectRoot}/tsconfig.lib.json",
+        "useLegacyTypescriptPlugin": true
+      }
+    }
+  }
+}
+```
+
+##### After
+
+```json title="nx.json"
+{
+  "targetDefaults": {
+    "@nx/rollup:rollup": {
+      "options": {
+        "outputPath": "dist/{projectRoot}",
+        "tsConfig": "{projectRoot}/tsconfig.lib.json"
+      }
+    }
+  }
+}
+```
+
+Remove `useLegacyTypescriptPlugin` from `withNx` calls in `rollup.config.*` files.
+
+##### Before
+
+```js title="libs/my-lib/rollup.config.cjs" {7}
+const { withNx } = require('@nx/rollup/with-nx');
+module.exports = withNx({
+  outputPath: '../../dist/libs/my-lib',
+  main: './src/index.ts',
+  tsConfig: './tsconfig.lib.json',
+  format: ['cjs', 'esm'],
+  useLegacyTypescriptPlugin: true,
+});
+```
+
+##### After
+
+```js title="libs/my-lib/rollup.config.cjs"
+const { withNx } = require('@nx/rollup/with-nx');
+module.exports = withNx({
+  outputPath: '../../dist/libs/my-lib',
+  main: './src/index.ts',
+  tsConfig: './tsconfig.lib.json',
+  format: ['cjs', 'esm'],
+});
+```

package/dist/src/migrations/update-23-0-0/rewrite-internal-subpath-imports.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+export default function rewriteInternalSubpathImports(tree: Tree): Promise<void>;
+export declare function rewriteSubpathImports(source: string): string;

package/dist/src/migrations/update-23-0-0/rewrite-internal-subpath-imports.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = rewriteInternalSubpathImports;
+exports.rewriteSubpathImports = rewriteSubpathImports;
+const devkit_1 = require("@nx/devkit");
+const TS_EXTENSIONS = ['.ts', '.tsx', '.cts', '.mts'];
+const FROM_PREFIX = '@nx/rollup/src/';
+const TO_PUBLIC = '@nx/rollup';
+const TO_INTERNAL = '@nx/rollup/internal';
+// Symbols exported from `@nx/rollup`'s public entry (packages/rollup/index.ts).
+// A named import/export of one of these from `@nx/rollup/src/*` is routed to
+// the public `@nx/rollup` entry; everything else goes to `@nx/rollup/internal`.
+const PUBLIC_SYMBOLS = new Set([
+    'AssetGlobPattern',
+    'Globals',
+    'RollupExecutorOptions',
+    'configurationGenerator',
+    'createRollupOptions',
+    'rollupExecutor',
+    'rollupInitGenerator',
+    'rollupProjectGenerator',
+]);
+// Methods on `jest` and `vi` that take a module specifier as their first arg.
+const MOCK_HELPER_METHODS = new Set([
+    'mock',
+    'unmock',
+    'doMock',
+    'dontMock',
+    'requireActual',
+    'requireMock',
+    'importActual',
+    'importMock',
+]);
+let ts;
+async function rewriteInternalSubpathImports(tree) {
+    let touchedCount = 0;
+    (0, devkit_1.visitNotIgnoredFiles)(tree, '.', (filePath) => {
+        if (!TS_EXTENSIONS.some((ext) => filePath.endsWith(ext))) {
+            return;
+        }
+        const original = tree.read(filePath, 'utf-8');
+        if (!original || !original.includes(FROM_PREFIX)) {
+            return;
+        }
+        const updated = rewriteSubpathImports(original);
+        if (updated !== original) {
+            tree.write(filePath, updated);
+            touchedCount += 1;
+        }
+    });
+    if (touchedCount > 0) {
+        devkit_1.logger.info(`Rewrote @nx/rollup/src/* imports in ${touchedCount} file(s) ` +
+            `(public symbols to @nx/rollup, internals to @nx/rollup/internal).`);
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}
+function rewriteSubpathImports(source) {
+    ts ??= (0, devkit_1.ensurePackage)('typescript', '*');
+    const sourceFile = ts.createSourceFile('tmp.ts', source, ts.ScriptTarget.Latest, 
+    /* setParentNodes */ true, ts.ScriptKind.TSX);
+    const changes = [];
+    for (const stmt of sourceFile.statements) {
+        if (ts.isImportDeclaration(stmt)) {
+            collectImportRewrite(sourceFile, stmt, changes);
+        }
+        else if (ts.isExportDeclaration(stmt)) {
+            collectExportRewrite(sourceFile, stmt, changes);
+        }
+    }
+    collectCallExpressionRewrites(sourceFile, changes);
+    return changes.length > 0 ? (0, devkit_1.applyChangesToString)(source, changes) : source;
+}
+function isSubpathSpecifier(node) {
+    return ts.isStringLiteral(node) && node.text.startsWith(FROM_PREFIX);
+}
+function collectImportRewrite(sourceFile, stmt, changes) {
+    if (!isSubpathSpecifier(stmt.moduleSpecifier)) {
+        return;
+    }
+    const clause = stmt.importClause;
+    // Pure named imports (`import { a, b } from '...'`) can be split by symbol.
+    // A default or namespace import grabs the whole module, so it can't be
+    // split — route it wholesale to the internal entry.
+    if (clause &&
+        !clause.name &&
+        clause.namedBindings &&
+        ts.isNamedImports(clause.namedBindings)) {
+        rewriteNamedDeclaration(sourceFile, stmt, stmt.moduleSpecifier, clause.isTypeOnly, clause.namedBindings.elements, 'import', changes);
+        return;
+    }
+    replaceSpecifier(sourceFile, stmt.moduleSpecifier, TO_INTERNAL, changes);
+}
+function collectExportRewrite(sourceFile, stmt, changes) {
+    if (!stmt.moduleSpecifier || !isSubpathSpecifier(stmt.moduleSpecifier)) {
+        return;
+    }
+    // `export { a, b } from '...'` can be split; `export * from '...'` cannot.
+    if (stmt.exportClause && ts.isNamedExports(stmt.exportClause)) {
+        rewriteNamedDeclaration(sourceFile, stmt, stmt.moduleSpecifier, stmt.isTypeOnly, stmt.exportClause.elements, 'export', changes);
+        return;
+    }
+    replaceSpecifier(sourceFile, stmt.moduleSpecifier, TO_INTERNAL, changes);
+}
+/**
+ * Partition the named bindings of an import/export declaration into the ones
+ * that resolve to `@nx/rollup`'s public entry and the ones that don't. If both
+ * groups are non-empty, the single declaration is split into two.
+ */
+function rewriteNamedDeclaration(sourceFile, decl, specifier, isTypeOnly, elements, keyword, changes) {
+    const publicEls = [];
+    const internalEls = [];
+    for (const el of elements) {
+        // `propertyName` is the original name in `orig as alias`; fall back to
+        // `name` for the plain `orig` form.
+        const importedName = (el.propertyName ?? el.name).text;
+        (PUBLIC_SYMBOLS.has(importedName) ? publicEls : internalEls).push(el);
+    }
+    if (publicEls.length === 0) {
+        replaceSpecifier(sourceFile, specifier, TO_INTERNAL, changes);
+        return;
+    }
+    if (internalEls.length === 0) {
+        replaceSpecifier(sourceFile, specifier, TO_PUBLIC, changes);
+        return;
+    }
+    // Mixed — replace the whole declaration with one statement per target.
+    const quote = sourceFile.text.charAt(specifier.getStart(sourceFile));
+    const start = decl.getStart(sourceFile);
+    const end = decl.getEnd();
+    const semicolon = sourceFile.text.charAt(end - 1) === ';' ? ';' : '';
+    const prefix = isTypeOnly ? `${keyword} type` : keyword;
+    const render = (els, target) => `${prefix} { ${els
+        .map((el) => el.getText(sourceFile))
+        .join(', ')} } from ${quote}${target}${quote}${semicolon}`;
+    changes.push({ type: devkit_1.ChangeType.Delete, start, length: end - start }, {
+        type: devkit_1.ChangeType.Insert,
+        index: start,
+        text: `${render(publicEls, TO_PUBLIC)}\n${render(internalEls, TO_INTERNAL)}`,
+    });
+}
+function collectCallExpressionRewrites(sourceFile, changes) {
+    const visit = (node) => {
+        if (ts.isCallExpression(node) &&
+            shouldRewriteCallExpression(node) &&
+            node.arguments.length >= 1 &&
+            isSubpathSpecifier(node.arguments[0])) {
+            // `require(...)`, dynamic `import(...)` and `jest.mock(...)` reference
+            // the module as a whole and can't be symbol-split, so they go to the
+            // internal entry.
+            replaceSpecifier(sourceFile, node.arguments[0], TO_INTERNAL, changes);
+        }
+        else if (ts.isImportTypeNode(node)) {
+            // `typeof import('...')` parses as an `ImportTypeNode`, not a
+            // CallExpression — its argument is `LiteralTypeNode<StringLiteral>`.
+            // The whole module is referenced, so it can't be symbol-split.
+            const literal = getImportTypeStringLiteral(node);
+            if (literal && literal.text.startsWith(FROM_PREFIX)) {
+                replaceSpecifier(sourceFile, literal, TO_INTERNAL, changes);
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+}
+function getImportTypeStringLiteral(node) {
+    const arg = node.argument;
+    if (arg && ts.isLiteralTypeNode(arg) && ts.isStringLiteral(arg.literal)) {
+        return arg.literal;
+    }
+    return undefined;
+}
+function shouldRewriteCallExpression(call) {
+    const callee = call.expression;
+    // `require('...')`
+    if (ts.isIdentifier(callee) && callee.text === 'require')
+        return true;
+    // dynamic `import('...')` (runtime form parses as a CallExpression whose
+    // callee is the `import` keyword). The `typeof import('...')` type-position
+    // form is an `ImportTypeNode` (handled in `collectCallExpressionRewrites`).
+    if (callee.kind === ts.SyntaxKind.ImportKeyword)
+        return true;
+    // `jest.mock(...)` / `vi.mock(...)` and friends.
+    if (ts.isPropertyAccessExpression(callee)) {
+        const obj = callee.expression;
+        if (ts.isIdentifier(obj) &&
+            (obj.text === 'jest' || obj.text === 'vi') &&
+            MOCK_HELPER_METHODS.has(callee.name.text)) {
+            return true;
+        }
+    }
+    return false;
+}
+function replaceSpecifier(sourceFile, literal, target, changes) {
+    const start = literal.getStart(sourceFile);
+    const end = literal.getEnd();
+    const quote = sourceFile.text.charAt(start);
+    changes.push({ type: devkit_1.ChangeType.Delete, start, length: end - start }, {
+        type: devkit_1.ChangeType.Insert,
+        index: start,
+        text: `${quote}${target}${quote}`,
+    });
+}

package/{src → dist/src}/plugins/analyze.d.ts

@@ -2,4 +2,3 @@ export declare function analyze(): {
     name: string;
     renderChunk(source: any, chunk: any): void;
 };
-//# sourceMappingURL=analyze.d.ts.map

package/{src → dist/src}/plugins/delete-output.d.ts

@@ -3,4 +3,3 @@ export interface DeleteOutputOptions {
     dirs: string[];
 }
 export declare function deleteOutput(options: DeleteOutputOptions): Plugin;
-//# sourceMappingURL=delete-output.d.ts.map

package/{src → dist/src}/plugins/nx-copy-assets.plugin.d.ts

@@ -1,5 +1,5 @@
 import type { Plugin } from 'rollup';
-import { AssetGlob } from '@nx/js/src/utils/assets/assets';
+import { AssetGlob } from '@nx/js/internal';
 export interface NxCopyAssetsPluginOptions {
     assets: (string | AssetGlob)[];
     outputPath: string;
@@ -21,4 +21,3 @@ export declare function extractGlobLiteralPrefix(glob: string): {
     glob: string;
 };
 export declare function nxCopyAssetsPlugin(options: NxCopyAssetsPluginOptions): Plugin;
-//# sourceMappingURL=nx-copy-assets.plugin.d.ts.map

package/{src → dist/src}/plugins/nx-copy-assets.plugin.js

@@ -4,7 +4,7 @@ exports.extractGlobLiteralPrefix = extractGlobLiteralPrefix;
 exports.nxCopyAssetsPlugin = nxCopyAssetsPlugin;
 const node_path_1 = require("node:path");
 const devkit_1 = require("@nx/devkit");
-const copy_assets_handler_1 = require("@nx/js/src/utils/assets/copy-assets-handler");
+const internal_1 = require("@nx/js/internal");
 /**
  * Splits a glob into its literal directory prefix and the remaining pattern.
  * CopyAssetsHandler expects input to be a directory and glob to be a pattern
@@ -60,7 +60,7 @@ function nxCopyAssetsPlugin(options) {
             const outputDir = (0, node_path_1.isAbsolute)(options.outputPath)
                 ? options.outputPath
                 : (0, node_path_1.join)(devkit_1.workspaceRoot, options.outputPath);
-            handler = new copy_assets_handler_1.CopyAssetsHandler({
+            handler = new internal_1.CopyAssetsHandler({
                 rootDir: devkit_1.workspaceRoot,
                 projectDir: options.projectRoot,
                 outputDir,

package/{src → dist/src}/plugins/package-json/generate-package-json.d.ts

@@ -11,4 +11,3 @@ export interface GeneratePackageJsonOptions {
 }
 export declare const pluginName = "rollup-plugin-nx-generate-package-json";
 export declare function generatePackageJson(options: GeneratePackageJsonOptions, packageJson: PackageJson): Plugin;
-//# sourceMappingURL=generate-package-json.d.ts.map

package/{src → dist/src}/plugins/package-json/update-package-json.d.ts

@@ -8,4 +8,3 @@ export declare function updatePackageJson(options: {
     outputFileName?: string;
     additionalEntryPoints?: string[];
 }, packageJson: PackageJson): void;
-//# sourceMappingURL=update-package-json.d.ts.map

package/{src → dist/src}/plugins/plugin.d.ts

@@ -1,4 +1,4 @@
-import { type CreateDependencies, CreateNodesV2 } from '@nx/devkit';
+import { type CreateDependencies, CreateNodes } from '@nx/devkit';
 /**
  * @deprecated The 'createDependencies' function is now a no-op. This functionality is included in 'createNodesV2'.
  */
@@ -8,6 +8,5 @@ export interface RollupPluginOptions {
     buildDepsTargetName?: string;
     watchDepsTargetName?: string;
 }
-export declare const createNodes: CreateNodesV2<RollupPluginOptions>;
-export declare const createNodesV2: CreateNodesV2<RollupPluginOptions>;
-//# sourceMappingURL=plugin.d.ts.map
+export declare const createNodes: CreateNodes<RollupPluginOptions>;
+export declare const createNodesV2: CreateNodes<RollupPluginOptions>;

package/{src → dist/src}/plugins/plugin.js

@@ -1,22 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNodesV2 = exports.createNodes = exports.createDependencies = void 0;
+const internal_1 = require("@nx/devkit/internal");
 const cache_directory_1 = require("nx/src/utils/cache-directory");
 const path_1 = require("path");
 const fs_1 = require("fs");
 const devkit_1 = require("@nx/devkit");
-const calculate_hash_for_create_nodes_1 = require("@nx/devkit/src/utils/calculate-hash-for-create-nodes");
 const js_1 = require("@nx/js");
-const get_named_inputs_1 = require("@nx/devkit/src/utils/get-named-inputs");
 const file_hasher_1 = require("nx/src/hasher/file-hasher");
-const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
-const util_1 = require("@nx/js/src/plugins/typescript/util");
-function readTargetsCache(cachePath) {
-    return (0, fs_1.existsSync)(cachePath) ? (0, devkit_1.readJsonFile)(cachePath) : {};
-}
-function writeTargetsToCache(cachePath, results) {
-    (0, devkit_1.writeJsonFile)(cachePath, results);
-}
+const internal_2 = require("@nx/js/internal");
 /**
  * @deprecated The 'createDependencies' function is now a no-op. This functionality is included in 'createNodesV2'.
  */
@@ -31,34 +23,50 @@ exports.createNodes = [
         const normalizedOptions = normalizeOptions(options);
         const optionsHash = (0, file_hasher_1.hashObject)(normalizedOptions);
         const cachePath = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, `rollup-${optionsHash}.hash`);
-        const targetsCache = readTargetsCache(cachePath);
-        const isTsSolutionSetup = (0, ts_solution_setup_1.isUsingTsSolutionSetup)();
-        const pmc = (0, devkit_1.getPackageManagerCommand)((0, devkit_1.detectPackageManager)(context.workspaceRoot));
+        const targetsCache = new internal_1.PluginCache(cachePath);
+        const isTsSolutionSetup = (0, internal_2.isUsingTsSolutionSetup)();
+        const packageManager = (0, devkit_1.detectPackageManager)(context.workspaceRoot);
+        const pmc = (0, devkit_1.getPackageManagerCommand)(packageManager);
+        const lockFileName = (0, js_1.getLockFileName)(packageManager);
         try {
-            return await (0, devkit_1.createNodesFromFiles)((configFile, _, context) => createNodesInternal(configFile, normalizedOptions, context, targetsCache, isTsSolutionSetup, pmc), configFilePaths, normalizedOptions, context);
+            const { entries, preErrors } = await filterRollupConfigs(configFilePaths, context);
+            const projectHashes = await (0, internal_1.calculateHashesForCreateNodes)(entries.map((e) => e.projectRoot), normalizedOptions, context, entries.map(() => [lockFileName]));
+            let results = [];
+            let nodeErrors = [];
+            try {
+                results = await (0, devkit_1.createNodesFromFiles)((configFile, _, ctx, idx) => createNodesInternal(configFile, normalizedOptions, ctx, targetsCache, isTsSolutionSetup, pmc, projectHashes[idx]), entries.map((e) => e.configFile), normalizedOptions, context);
+            }
+            catch (e) {
+                if (e instanceof devkit_1.AggregateCreateNodesError) {
+                    results = e.partialResults ?? [];
+                    nodeErrors = e.errors;
+                }
+                else {
+                    throw e;
+                }
+            }
+            const allErrors = [...preErrors, ...nodeErrors];
+            if (allErrors.length > 0) {
+                throw new devkit_1.AggregateCreateNodesError(allErrors, results);
+            }
+            return results;
         }
         finally {
-            writeTargetsToCache(cachePath, targetsCache);
+            targetsCache.writeToDisk();
         }
     },
 ];
 exports.createNodesV2 = exports.createNodes;
-async function createNodesInternal(configFilePath, options, context, targetsCache, isTsSolutionSetup, pmc) {
+async function createNodesInternal(configFilePath, options, context, targetsCache, isTsSolutionSetup, pmc, hash) {
     const projectRoot = (0, path_1.dirname)(configFilePath);
-    const fullyQualifiedProjectRoot = (0, path_1.join)(context.workspaceRoot, projectRoot);
-    // Do not create a project if package.json and project.json do not exist
-    const siblingFiles = (0, fs_1.readdirSync)(fullyQualifiedProjectRoot);
-    if (!siblingFiles.includes('package.json') &&
-        !siblingFiles.includes('project.json')) {
-        return {};
+    if (!targetsCache.has(hash)) {
+        targetsCache.set(hash, await buildRollupTarget(configFilePath, projectRoot, options, context, isTsSolutionSetup, pmc));
     }
-    const hash = await (0, calculate_hash_for_create_nodes_1.calculateHashForCreateNodes)(projectRoot, options, context, [(0, js_1.getLockFileName)((0, devkit_1.detectPackageManager)(context.workspaceRoot))]);
-    targetsCache[hash] ??= await buildRollupTarget(configFilePath, projectRoot, options, context, isTsSolutionSetup, pmc);
     return {
         projects: {
             [projectRoot]: {
                 root: projectRoot,
-                targets: targetsCache[hash],
+                targets: targetsCache.get(hash),
             },
         },
     };
@@ -82,7 +90,7 @@ async function buildRollupTarget(configFilePath, projectRoot, options, context,
     }
     const isTsConfig = configFilePath.endsWith('ts');
     const tsConfigPlugin = '@rollup/plugin-typescript';
-    const namedInputs = (0, get_named_inputs_1.getNamedInputs)(projectRoot, context);
+    const namedInputs = (0, internal_1.getNamedInputs)(projectRoot, context);
     const rollupConfig = (await loadConfigFile((0, devkit_1.joinPathFragments)(context.workspaceRoot, configFilePath), isTsConfig ? { configPlugin: tsConfigPlugin } : {}, true // Enable watch mode so that rollup properly reloads config files without reusing a cached version
     )).options;
     const outputs = getOutputs(rollupConfig, projectRoot);
@@ -99,6 +107,7 @@ async function buildRollupTarget(configFilePath, projectRoot, options, context,
                 ? ['production', '^production']
                 : ['default', '^default']),
             { externalDependencies: ['rollup'] },
+            internal_2.TS_SOLUTION_SETUP_TSCONFIG_INPUT,
         ],
         outputs,
         metadata: {
@@ -120,7 +129,7 @@ async function buildRollupTarget(configFilePath, projectRoot, options, context,
             '@nx/js:typescript-sync',
         ];
     }
-    (0, util_1.addBuildAndWatchDepsTargets)(context.workspaceRoot, projectRoot, targets, options, pmc);
+    (0, internal_2.addBuildAndWatchDepsTargets)(context.workspaceRoot, projectRoot, targets, options, pmc);
     return targets;
 }
 function getOutputs(rollupConfigs, projectRoot) {
@@ -149,6 +158,28 @@ function getOutputs(rollupConfigs, projectRoot) {
     }
     return Array.from(outputs);
 }
+async function filterRollupConfigs(configFiles, context) {
+    const preErrors = [];
+    const candidates = await Promise.all(configFiles.map(async (configFile) => {
+        try {
+            const projectRoot = (0, path_1.dirname)(configFile);
+            const siblingFiles = (0, fs_1.readdirSync)((0, path_1.join)(context.workspaceRoot, projectRoot));
+            if (!siblingFiles.includes('package.json') &&
+                !siblingFiles.includes('project.json')) {
+                return null;
+            }
+            return { configFile, projectRoot };
+        }
+        catch (e) {
+            preErrors.push([configFile, e]);
+            return null;
+        }
+    }));
+    return {
+        entries: candidates.filter((c) => c !== null),
+        preErrors,
+    };
+}
 function normalizeOptions(options) {
     return {
         buildTargetName: options.buildTargetName ?? 'build',

package/{src → dist/src}/plugins/postcss/index.d.ts

@@ -13,4 +13,3 @@
 export { postcss } from './postcss-plugin';
 export { postcss as default } from './postcss-plugin';
 export type { PostCSSPluginOptions, PostCSSModulesOptions, FilterPattern, UseOptions, LessOptions, SassOptions, StylusOptions, } from './options';
-//# sourceMappingURL=index.d.ts.map

package/{src → dist/src}/plugins/postcss/loaders/index.d.ts

@@ -35,4 +35,3 @@ export declare class Loaders {
      */
     process(code: string, context: LoaderContext): Promise<LoaderResult>;
 }
-//# sourceMappingURL=index.d.ts.map

package/{src → dist/src}/plugins/postcss/loaders/less-loader.d.ts

@@ -4,4 +4,3 @@ import type { Loader, LessLoaderOptions } from './types';
  * Compiles .less files to CSS
  */
 export declare function createLessLoader(options?: LessLoaderOptions): Loader;
-//# sourceMappingURL=less-loader.d.ts.map