@nx/webpack 23.0.0-pr.35465.2bc2643 → 23.0.0-rc.1

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

@@ -0,0 +1,225 @@
+"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/webpack/src/';
+const TO_PUBLIC = '@nx/webpack';
+const TO_INTERNAL = '@nx/webpack/internal';
+// Symbols exported from `@nx/webpack`'s public entry (packages/webpack/index.ts).
+// A named import/export of one of these from `@nx/webpack/src/*` is routed to
+// the public `@nx/webpack` entry; everything else goes to `@nx/webpack/internal`.
+const PUBLIC_SYMBOLS = new Set([
+    'AssetGlobPattern',
+    'AsyncNxComposableWebpackPlugin',
+    'FileReplacement',
+    'MergedOptions',
+    'NormalizedWebpackExecutorOptions',
+    'NxComposableWebpackPlugin',
+    'NxWebpackExecutionContext',
+    'NxWebpackPlugin',
+    'WebDevServerOptions',
+    'WebpackExecutorEvent',
+    'WebpackExecutorOptions',
+    'WithNxOptions',
+    'WithWebOptions',
+    'composePlugins',
+    'composePluginsSync',
+    'configurationGenerator',
+    'convertConfigToWebpackPluginGenerator',
+    'createCopyPlugin',
+    'devServerExecutor',
+    'getCSSModuleLocalIdent',
+    'getWebpackE2EWebServerInfo',
+    'isNxWebpackComposablePlugin',
+    'normalizeOptions',
+    'normalizePluginPath',
+    'nxWebpackComposablePlugin',
+    'useLegacyNxPlugin',
+    'webpackExecutor',
+    'webpackInitGenerator',
+    'webpackProjectGenerator',
+    'withNx',
+    'withWeb',
+]);
+// 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/webpack/src/* imports in ${touchedCount} file(s) ` +
+            `(public symbols to @nx/webpack, internals to @nx/webpack/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/webpack`'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/generate-package-json-plugin.d.ts

@@ -15,4 +15,3 @@ export declare class GeneratePackageJsonPlugin implements WebpackPluginInstance
     private resolveRuntimeDependencies;
     apply(compiler: Compiler): void;
 }
-//# sourceMappingURL=generate-package-json-plugin.d.ts.map

package/{src → dist/src}/plugins/nx-typescript-webpack-plugin/nx-tsconfig-paths-webpack-plugin.d.ts

@@ -6,4 +6,3 @@ export declare class NxTsconfigPathsWebpackPlugin {
     apply(compiler: Compiler): void;
     handleBuildLibsFromSource(config: Partial<WebpackOptionsNormalized | Configuration>, options: NormalizedNxAppWebpackPluginOptions): void;
 }
-//# sourceMappingURL=nx-tsconfig-paths-webpack-plugin.d.ts.map

package/{src → dist/src}/plugins/nx-typescript-webpack-plugin/nx-tsconfig-paths-webpack-plugin.js

@@ -5,8 +5,8 @@ const tslib_1 = require("tslib");
 const path = tslib_1.__importStar(require("path"));
 const tsconfig_paths_webpack_plugin_1 = require("tsconfig-paths-webpack-plugin");
 const devkit_1 = require("@nx/devkit");
-const buildable_libs_utils_1 = require("@nx/js/src/utils/buildable-libs-utils");
-const ts_config_1 = require("@nx/js/src/utils/typescript/ts-config");
+const internal_1 = require("@nx/js/internal");
+const js_1 = require("@nx/js");
 const webpack_nx_build_coordination_plugin_1 = require("../webpack-nx-build-coordination-plugin");
 class NxTsconfigPathsWebpackPlugin {
     constructor(options) {
@@ -30,7 +30,7 @@ class NxTsconfigPathsWebpackPlugin {
             : this.options.tsConfig;
         compiler.options.resolve.plugins.push(new tsconfig_paths_webpack_plugin_1.TsconfigPathsPlugin({
             configFile,
-            baseUrl: (0, ts_config_1.resolvePathsBaseUrl)(configFile),
+            baseUrl: (0, js_1.resolvePathsBaseUrl)(configFile),
             extensions: Array.from(extensions),
             mainFields: ['module', 'main'],
         }));
@@ -38,8 +38,8 @@ class NxTsconfigPathsWebpackPlugin {
     handleBuildLibsFromSource(config, options) {
         if (!options.buildLibsFromSource && options.targetName) {
             const remappedTarget = options.targetName === 'serve' ? 'build' : options.targetName;
-            const { target, dependencies } = (0, buildable_libs_utils_1.calculateProjectBuildableDependencies)(undefined, options.projectGraph, options.root, options.projectName, remappedTarget, options.configurationName);
-            options.tsConfig = (0, buildable_libs_utils_1.createTmpTsConfig)(options.tsConfig, options.root, target.data.root, dependencies);
+            const { target, dependencies } = (0, internal_1.calculateProjectBuildableDependencies)(undefined, options.projectGraph, options.root, options.projectName, remappedTarget, options.configurationName);
+            options.tsConfig = (0, internal_1.createTmpTsConfig)(options.tsConfig, options.root, target.data.root, dependencies);
             if (options.targetName === 'serve') {
                 const buildableDependencies = dependencies
                     .filter((dependency) => dependency.node.type === 'lib')

package/{src → dist/src}/plugins/nx-webpack-plugin/lib/apply-base-config.d.ts

@@ -3,4 +3,3 @@ import { NormalizedNxAppWebpackPluginOptions } from '../nx-app-webpack-plugin-op
 export declare function applyBaseConfig(options: NormalizedNxAppWebpackPluginOptions, config?: Partial<WebpackOptionsNormalized | Configuration>, { useNormalizedEntry, }?: {
     useNormalizedEntry?: boolean;
 }): void;
-//# sourceMappingURL=apply-base-config.d.ts.map

package/{src → dist/src}/plugins/nx-webpack-plugin/lib/apply-base-config.js

@@ -15,7 +15,7 @@ const get_terser_ecma_version_1 = require("./get-terser-ecma-version");
 const compiler_loaders_1 = require("./compiler-loaders");
 const TerserPlugin = require("terser-webpack-plugin");
 const nodeExternals = require("webpack-node-externals");
-const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
+const internal_1 = require("@nx/js/internal");
 const utils_1 = require("./utils");
 const IGNORED_WEBPACK_WARNINGS = [
     /The comment file/i,
@@ -208,7 +208,7 @@ function applyNxDependentConfig(options, config, { useNormalizedEntry } = {}) {
         configurationName: options.configurationName,
         root: options.root,
     };
-    const isUsingTsSolution = (0, ts_solution_setup_1.isUsingTsSolutionSetup)();
+    const isUsingTsSolution = (0, internal_1.isUsingTsSolutionSetup)();
     options.useTsconfigPaths ??= !isUsingTsSolution;
     // If the project is using ts solutions setup, the paths are not in tsconfig and we should not use the plugin's paths.
     if (options.useTsconfigPaths) {

package/{src → dist/src}/plugins/nx-webpack-plugin/lib/apply-web-config.d.ts

@@ -3,4 +3,3 @@ import { NormalizedNxAppWebpackPluginOptions } from '../nx-app-webpack-plugin-op
 export declare function applyWebConfig(options: NormalizedNxAppWebpackPluginOptions, config?: Partial<WebpackOptionsNormalized | Configuration>, { useNormalizedEntry, }?: {
     useNormalizedEntry?: boolean;
 }): void;
-//# sourceMappingURL=apply-web-config.d.ts.map

package/{src → dist/src}/plugins/nx-webpack-plugin/lib/apply-web-config.js

@@ -118,7 +118,7 @@ function applyWebConfig(options, config = {}, { useNormalizedEntry, } = {}) {
             use: [
                 ...(0, stylesheet_loaders_1.getCommonLoadersForCssModules)(options, includePaths),
                 {
-                    loader: require.resolve('less-loader'),
+                    loader: path.join(__dirname, '../../../utils/webpack/deprecated-less-loader.js'),
                     options: {
                         lessOptions: {
                             paths: includePaths,
@@ -163,7 +163,7 @@ function applyWebConfig(options, config = {}, { useNormalizedEntry, } = {}) {
             use: [
                 ...(0, stylesheet_loaders_1.getCommonLoadersForGlobalCss)(options, includePaths),
                 {
-                    loader: require.resolve('less-loader'),
+                    loader: path.join(__dirname, '../../../utils/webpack/deprecated-less-loader.js'),
                     options: {
                         sourceMap: !!options.sourceMap,
                         lessOptions: {
@@ -210,7 +210,7 @@ function applyWebConfig(options, config = {}, { useNormalizedEntry, } = {}) {
             use: [
                 ...(0, stylesheet_loaders_1.getCommonLoadersForGlobalStyle)(options, includePaths),
                 {
-                    loader: require.resolve('less-loader'),
+                    loader: path.join(__dirname, '../../../utils/webpack/deprecated-less-loader.js'),
                     options: {
                         sourceMap: !!options.sourceMap,
                         lessOptions: {

package/{src → dist/src}/plugins/nx-webpack-plugin/lib/compiler-loaders.d.ts

@@ -53,4 +53,3 @@ export declare function createLoaderFromCompiler(options: NormalizedNxAppWebpack
         jsc?: undefined;
     };
 };
-//# sourceMappingURL=compiler-loaders.d.ts.map

package/{src → dist/src}/plugins/nx-webpack-plugin/lib/get-terser-ecma-version.d.ts

@@ -1,2 +1 @@
 export declare function getTerserEcmaVersion(projectRoot: string): 2020 | 5;
-//# sourceMappingURL=get-terser-ecma-version.d.ts.map

package/{src → dist/src}/plugins/nx-webpack-plugin/lib/instantiate-script-plugins.d.ts

@@ -1,4 +1,3 @@
 import { WebpackPluginInstance } from 'webpack';
 import { NormalizedNxAppWebpackPluginOptions } from '../nx-app-webpack-plugin-options';
 export declare function instantiateScriptPlugins(options: NormalizedNxAppWebpackPluginOptions): WebpackPluginInstance[];
-//# sourceMappingURL=instantiate-script-plugins.d.ts.map

package/{src → dist/src}/plugins/nx-webpack-plugin/lib/normalize-options.d.ts

@@ -2,4 +2,3 @@ import { AssetGlobPattern, FileReplacement, NormalizedNxAppWebpackPluginOptions,
 export declare function normalizeOptions(options: NxAppWebpackPluginOptions): NormalizedNxAppWebpackPluginOptions;
 export declare function normalizeAssets(assets: any[], root: string, sourceRoot: string, projectRoot: string, resolveRelativePathsToProjectRoot?: boolean): AssetGlobPattern[];
 export declare function normalizeFileReplacements(root: string, fileReplacements: FileReplacement[]): FileReplacement[];
-//# sourceMappingURL=normalize-options.d.ts.map

package/{src → dist/src}/plugins/nx-webpack-plugin/lib/normalize-options.js

@@ -4,7 +4,7 @@ exports.normalizeOptions = normalizeOptions;
 exports.normalizeAssets = normalizeAssets;
 exports.normalizeFileReplacements = normalizeFileReplacements;
 const devkit_1 = require("@nx/devkit");
-const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
+const internal_1 = require("@nx/js/internal");
 const fs_1 = require("fs");
 const path_1 = require("path");
 function normalizeOptions(options) {
@@ -49,7 +49,7 @@ function normalizeOptions(options) {
         // executor options take precedence (especially for overriding with CLI args)
         originalTargetOptions);
     }
-    const sourceRoot = (0, ts_solution_setup_1.getProjectSourceRoot)(projectNode.data);
+    const sourceRoot = (0, internal_1.getProjectSourceRoot)(projectNode.data);
     if (!combinedPluginAndMaybeExecutorOptions.main) {
         throw new Error(`Missing "main" option for the entry file. Set this option in your Nx webpack plugin.`);
     }

package/{src → dist/src}/plugins/nx-webpack-plugin/lib/stylesheet-loaders.d.ts

@@ -71,4 +71,3 @@ export declare function getCommonLoadersForGlobalStyle(options: NormalizedNxAppW
     };
 })[];
 export {};
-//# sourceMappingURL=stylesheet-loaders.d.ts.map

package/{src → dist/src}/plugins/nx-webpack-plugin/lib/utils.d.ts

@@ -24,4 +24,3 @@ export declare function getAllTransitiveDeps(graph: ProjectGraph, targetName: st
  * @returns A list of all non-buildable libraries that the project depends on, including transitive dependencies.
  */
 export declare function getNonBuildableLibs(graph: ProjectGraph, projectName: string): (string | RegExp)[];
-//# sourceMappingURL=utils.d.ts.map

package/{src → dist/src}/plugins/nx-webpack-plugin/nx-app-webpack-plugin-options.d.ts

@@ -1,5 +1,5 @@
 import { ProjectGraph } from '@nx/devkit';
-import { AssetGlob } from '@nx/js/src/utils/assets/assets';
+import { AssetGlob } from '@nx/js/internal';
 export interface AssetGlobPattern {
     glob: string;
     input: string;
@@ -271,4 +271,3 @@ export interface NormalizedNxAppWebpackPluginOptions extends NxAppWebpackPluginO
     outputFileName: string;
     assets: AssetGlobPattern[];
 }
-//# sourceMappingURL=nx-app-webpack-plugin-options.d.ts.map

package/{src → dist/src}/plugins/nx-webpack-plugin/nx-app-webpack-plugin.d.ts

@@ -15,4 +15,3 @@ export declare class NxAppWebpackPlugin {
     constructor(options?: NxAppWebpackPluginOptions);
     apply(compiler: Compiler): void;
 }
-//# sourceMappingURL=nx-app-webpack-plugin.d.ts.map

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

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

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

@@ -1,24 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNodesV2 = exports.createNodes = exports.createDependencies = void 0;
+const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
-const calculate_hash_for_create_nodes_1 = require("@nx/devkit/src/utils/calculate-hash-for-create-nodes");
-const get_named_inputs_1 = require("@nx/devkit/src/utils/get-named-inputs");
 const js_1 = require("@nx/js");
-const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
+const internal_2 = require("@nx/js/internal");
 const fs_1 = require("fs");
 const file_hasher_1 = require("nx/src/hasher/file-hasher");
 const cache_directory_1 = require("nx/src/utils/cache-directory");
 const path_1 = require("path");
 const read_webpack_options_1 = require("../utils/webpack/read-webpack-options");
 const resolve_user_defined_webpack_config_1 = require("../utils/webpack/resolve-user-defined-webpack-config");
-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);
-}
 /**
  * @deprecated The 'createDependencies' function is now a no-op. This functionality is included in 'createNodesV2'.
  */
@@ -32,30 +24,47 @@ exports.createNodes = [
     async (configFilePaths, options, context) => {
         const optionsHash = (0, file_hasher_1.hashObject)(options);
         const cachePath = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, `webpack-${optionsHash}.hash`);
-        const targetsCache = readTargetsCache(cachePath);
+        const targetsCache = new internal_1.PluginCache(cachePath);
         const normalizedOptions = normalizeOptions(options);
-        const isTsSolutionSetup = (0, ts_solution_setup_1.isUsingTsSolutionSetup)();
-        const pmc = (0, devkit_1.getPackageManagerCommand)((0, devkit_1.detectPackageManager)(context.workspaceRoot));
+        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, options, context) => createNodesInternal(configFile, options, context, targetsCache, isTsSolutionSetup, pmc), configFilePaths, normalizedOptions, context);
+            const { entries, preErrors } = await filterWebpackConfigs(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, opts, ctx, idx) => createNodesInternal(configFile, opts, 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);
-    // Do not create a project if package.json and project.json isn't there.
-    const siblingFiles = (0, fs_1.readdirSync)((0, path_1.join)(context.workspaceRoot, projectRoot));
-    if (!siblingFiles.includes('package.json') &&
-        !siblingFiles.includes('project.json')) {
-        return {};
+    if (!targetsCache.has(hash)) {
+        targetsCache.set(hash, await createWebpackTargets(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 createWebpackTargets(configFilePath, projectRoot, options, context, isTsSolutionSetup, pmc);
-    const { targets, metadata } = targetsCache[hash];
+    const { targets, metadata } = targetsCache.get(hash);
     return {
         projects: {
             [projectRoot]: {
@@ -67,7 +76,7 @@ async function createNodesInternal(configFilePath, options, context, targetsCach
     };
 }
 async function createWebpackTargets(configFilePath, projectRoot, options, context, isTsSolutionSetup, pmc) {
-    const namedInputs = (0, get_named_inputs_1.getNamedInputs)(projectRoot, context);
+    const namedInputs = (0, internal_1.getNamedInputs)(projectRoot, context);
     const webpackConfig = (0, resolve_user_defined_webpack_config_1.resolveUserDefinedWebpackConfig)((0, path_1.join)(context.workspaceRoot, configFilePath), (0, js_1.getRootTsConfigPath)(), true);
     const webpackOptions = await (0, read_webpack_options_1.readWebpackOptions)(webpackConfig);
     const outputs = [];
@@ -79,7 +88,7 @@ async function createWebpackTargets(configFilePath, projectRoot, options, contex
     const targets = {};
     targets[options.buildTargetName] = {
         command: `webpack-cli build`,
-        options: { cwd: projectRoot, args: ['--node-env=production'] },
+        options: { cwd: projectRoot, env: { NODE_ENV: 'production' } },
         cache: true,
         dependsOn: [`^${options.buildTargetName}`],
         inputs: 'production' in namedInputs
@@ -89,6 +98,7 @@ async function createWebpackTargets(configFilePath, projectRoot, options, contex
                 {
                     externalDependencies: ['webpack-cli'],
                 },
+                internal_2.TS_SOLUTION_SETUP_TSCONFIG_INPUT,
             ]
             : [
                 'default',
@@ -96,6 +106,7 @@ async function createWebpackTargets(configFilePath, projectRoot, options, contex
                 {
                     externalDependencies: ['webpack-cli'],
                 },
+                internal_2.TS_SOLUTION_SETUP_TSCONFIG_INPUT,
             ],
         outputs,
         metadata: {
@@ -117,7 +128,7 @@ async function createWebpackTargets(configFilePath, projectRoot, options, contex
         command: `webpack-cli serve`,
         options: {
             cwd: projectRoot,
-            args: ['--node-env=development'],
+            env: { NODE_ENV: 'development' },
         },
         metadata: {
             technologies: ['webpack'],
@@ -137,7 +148,7 @@ async function createWebpackTargets(configFilePath, projectRoot, options, contex
         command: `webpack-cli serve`,
         options: {
             cwd: projectRoot,
-            args: ['--node-env=production'],
+            env: { NODE_ENV: 'production' },
         },
         metadata: {
             technologies: ['webpack'],
@@ -180,7 +191,7 @@ async function createWebpackTargets(configFilePath, projectRoot, options, contex
             '@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, metadata: {} };
 }
 function normalizeOutputPath(outputPath, projectRoot) {
@@ -211,6 +222,28 @@ function normalizeOutputPath(outputPath, projectRoot) {
         }
     }
 }
+async function filterWebpackConfigs(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/stats-json-plugin.d.ts

@@ -2,4 +2,3 @@ import { Compiler } from 'webpack';
 export declare class StatsJsonPlugin {
     apply(compiler: Compiler): void;
 }
-//# sourceMappingURL=stats-json-plugin.d.ts.map

package/{src → dist/src}/plugins/use-legacy-nx-plugin/use-legacy-nx-plugin.d.ts

@@ -29,4 +29,3 @@ module.exports = async () => ({
 export declare function useLegacyNxPlugin(fn: (config: Configuration, ctx: NxWebpackExecutionContext) => Promise<Configuration>, executorOptions: NxAppWebpackPluginOptions): Promise<{
     apply(compiler: Compiler): void;
 }>;
-//# sourceMappingURL=use-legacy-nx-plugin.d.ts.map

package/{src → dist/src}/plugins/webpack-nx-build-coordination-plugin.d.ts

@@ -19,4 +19,3 @@ export declare class WebpackNxBuildCoordinationPlugin {
     private createFileWatcher;
 }
 export {};
-//# sourceMappingURL=webpack-nx-build-coordination-plugin.d.ts.map

package/{src → dist/src}/plugins/write-index-html-plugin.d.ts

@@ -20,4 +20,3 @@ export declare class WriteIndexHtmlPlugin {
     private generateSriAttributes;
     private filterAndMapBuildFiles;
 }
-//# sourceMappingURL=write-index-html-plugin.d.ts.map

package/{src → dist/src}/utils/config.d.ts

@@ -14,10 +14,21 @@ export interface NxComposableWebpackPlugin {
 export interface AsyncNxComposableWebpackPlugin {
     (config: Configuration, ctx: NxWebpackExecutionContext): Configuration | Promise<Configuration>;
 }
+/**
+ * @deprecated Will be removed in Nx v24. Use `NxAppWebpackPlugin` from
+ * `@nx/webpack/app-plugin` in a standard webpack config and run
+ * `nx g @nx/webpack:convert-to-inferred`. See
+ * https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.
+ */
 export declare function composePlugins(...plugins: (NxComposableWebpackPlugin | AsyncNxComposableWebpackPlugin | Promise<NxComposableWebpackPlugin | AsyncNxComposableWebpackPlugin>)[]): ((config: Configuration, ctx: NxWebpackExecutionContext) => Promise<Configuration>) & {
     nxWebpackComposablePlugin: boolean;
 };
+/**
+ * @deprecated Will be removed in Nx v24. Use `NxAppWebpackPlugin` from
+ * `@nx/webpack/app-plugin` in a standard webpack config and run
+ * `nx g @nx/webpack:convert-to-inferred`. See
+ * https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.
+ */
 export declare function composePluginsSync(...plugins: NxComposableWebpackPlugin[]): ((config: Configuration, ctx: NxWebpackExecutionContext) => Configuration) & {
     nxWebpackComposablePlugin: boolean;
 };
-//# sourceMappingURL=config.d.ts.map