@nx/webpack 17.0.2 → 17.0.4

package/src/plugins/plugin.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodes = exports.createDependencies = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const get_named_inputs_1 = require("@nx/devkit/src/utils/get-named-inputs");
+const fs_1 = require("fs");
+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 js_1 = require("@nx/js");
+const cache_directory_1 = require("nx/src/utils/cache-directory");
+const calculate_hash_for_create_nodes_1 = require("@nx/devkit/src/utils/calculate-hash-for-create-nodes");
+const cachePath = (0, path_1.join)(cache_directory_1.projectGraphCacheDirectory, 'webpack.hash');
+const targetsCache = (0, fs_1.existsSync)(cachePath) ? readTargetsCache() : {};
+const calculatedTargets = {};
+function readTargetsCache() {
+    return (0, devkit_1.readJsonFile)(cachePath);
+}
+function writeTargetsToCache(targets) {
+    (0, devkit_1.writeJsonFile)(cachePath, targets);
+}
+const createDependencies = () => {
+    writeTargetsToCache(calculatedTargets);
+    return [];
+};
+exports.createDependencies = createDependencies;
+exports.createNodes = [
+    '**/webpack.config.{js,ts,mjs,cjs}',
+    async (configFilePath, options, context) => {
+        options ??= {};
+        options.buildTargetName ??= 'build';
+        options.serveTargetName ??= 'serve';
+        options.serveStaticTargetName ??= 'serve-static';
+        options.previewTargetName ??= 'preview';
+        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 {};
+        }
+        const hash = (0, calculate_hash_for_create_nodes_1.calculateHashForCreateNodes)(projectRoot, options, context, [
+            (0, js_1.getLockFileName)((0, devkit_1.detectPackageManager)(context.workspaceRoot)),
+        ]);
+        const targets = targetsCache[hash]
+            ? targetsCache[hash]
+            : await createWebpackTargets(configFilePath, projectRoot, options, context);
+        return {
+            projects: {
+                [projectRoot]: {
+                    projectType: 'application',
+                    targets,
+                },
+            },
+        };
+    },
+];
+async function createWebpackTargets(configFilePath, projectRoot, options, context) {
+    const namedInputs = (0, get_named_inputs_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 outputPath = normalizeOutputPath(webpackOptions.output?.path, projectRoot);
+    const targets = {};
+    targets[options.buildTargetName] = {
+        command: `webpack-cli build`,
+        options: { cwd: projectRoot, args: ['--node-env=production'] },
+        cache: true,
+        dependsOn: [`^${options.buildTargetName}`],
+        inputs: 'production' in namedInputs
+            ? [
+                'production',
+                '^production',
+                {
+                    externalDependencies: ['webpack-cli'],
+                },
+            ]
+            : [
+                'default',
+                '^default',
+                {
+                    externalDependencies: ['webpack-cli'],
+                },
+            ],
+        outputs: [outputPath],
+    };
+    targets[options.serveTargetName] = {
+        command: `webpack-cli serve`,
+        options: {
+            cwd: projectRoot,
+            args: ['--node-env=development'],
+        },
+    };
+    targets[options.previewTargetName] = {
+        command: `webpack-cli serve`,
+        options: {
+            cwd: projectRoot,
+            args: ['--node-env=production'],
+        },
+    };
+    targets[options.serveStaticTargetName] = {
+        executor: '@nx/web:file-server',
+        options: {
+            buildTarget: options.buildTargetName,
+            spa: true,
+        },
+    };
+    return targets;
+}
+function normalizeOutputPath(outputPath, projectRoot) {
+    if (!outputPath) {
+        // If outputPath is undefined, use webpack's default `dist` directory.
+        if (projectRoot === '.') {
+            return `{projectRoot}/dist}`;
+        }
+        else {
+            return `{workspaceRoot}/dist/{projectRoot}`;
+        }
+    }
+    else {
+        if ((0, path_1.isAbsolute)(outputPath)) {
+            return `{workspaceRoot}/${(0, path_1.relative)(devkit_1.workspaceRoot, outputPath)}`;
+        }
+        else {
+            if (outputPath.startsWith('..')) {
+                return (0, path_1.join)('{workspaceRoot}', (0, path_1.join)(projectRoot, outputPath));
+            }
+            else {
+                return (0, path_1.join)('{projectRoot}', outputPath);
+            }
+        }
+    }
+}

package/src/utils/config.d.ts

@@ -1,17 +1,22 @@
 import { ExecutorContext } from '@nx/devkit';
 import { Configuration } from 'webpack';
 import { NormalizedWebpackExecutorOptions } from '../executors/webpack/schema';
-/** @deprecated use withNx and withWeb plugins directly */
-export declare function getBaseWebpackPartial(options: NormalizedWebpackExecutorOptions, context?: ExecutorContext): Configuration;
+export declare const nxWebpackComposablePlugin = "nxWebpackComposablePlugin";
+export declare function isNxWebpackComposablePlugin(a: unknown): a is AsyncNxComposableWebpackPlugin;
 export interface NxWebpackExecutionContext {
     options: NormalizedWebpackExecutorOptions;
     context: ExecutorContext;
+    configuration?: string;
 }
-export interface NxWebpackPlugin {
+export interface NxComposableWebpackPlugin {
     (config: Configuration, ctx: NxWebpackExecutionContext): Configuration;
 }
-export interface AsyncNxWebpackPlugin {
+export interface AsyncNxComposableWebpackPlugin {
     (config: Configuration, ctx: NxWebpackExecutionContext): Configuration | Promise<Configuration>;
 }
-export declare function composePlugins(...plugins: (NxWebpackPlugin | AsyncNxWebpackPlugin | Promise<NxWebpackPlugin | AsyncNxWebpackPlugin>)[]): (config: Configuration, ctx: NxWebpackExecutionContext) => Promise<Configuration>;
-export declare function composePluginsSync(...plugins: NxWebpackPlugin[]): (config: Configuration, ctx: NxWebpackExecutionContext) => Configuration;
+export declare function composePlugins(...plugins: (NxComposableWebpackPlugin | AsyncNxComposableWebpackPlugin | Promise<NxComposableWebpackPlugin | AsyncNxComposableWebpackPlugin>)[]): ((config: Configuration, ctx: NxWebpackExecutionContext) => Promise<Configuration>) & {
+    nxWebpackComposablePlugin: boolean;
+};
+export declare function composePluginsSync(...plugins: NxComposableWebpackPlugin[]): ((config: Configuration, ctx: NxWebpackExecutionContext) => Configuration) & {
+    nxWebpackComposablePlugin: boolean;
+};

package/src/utils/config.js

@@ -1,31 +1,66 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.composePluginsSync = exports.composePlugins = exports.getBaseWebpackPartial = void 0;
-const with_nx_1 = require("./with-nx");
-const with_web_1 = require("./with-web");
-/** @deprecated use withNx and withWeb plugins directly */
-function getBaseWebpackPartial(options, context) {
-    const config = {};
-    const configure = composePluginsSync((0, with_nx_1.withNx)(), (0, with_web_1.withWeb)());
-    return configure(config, { options, context });
+exports.composePluginsSync = exports.composePlugins = exports.isNxWebpackComposablePlugin = exports.nxWebpackComposablePlugin = void 0;
+const devkit_1 = require("@nx/devkit");
+exports.nxWebpackComposablePlugin = 'nxWebpackComposablePlugin';
+function isNxWebpackComposablePlugin(a) {
+    return a?.[exports.nxWebpackComposablePlugin] === true;
 }
-exports.getBaseWebpackPartial = getBaseWebpackPartial;
+exports.isNxWebpackComposablePlugin = isNxWebpackComposablePlugin;
 function composePlugins(...plugins) {
-    return async function combined(config, ctx) {
+    return Object.assign(async function combined(config, ctx) {
+        // Webpack may be calling us as a standard config function.
+        // Build up Nx context from environment variables.
+        // This is to enable `@nx/webpack/plugin` to work with existing projects.
+        if (ctx['env']) {
+            ensureNxWebpackExecutionContext(ctx);
+            // Build this from scratch since what webpack passes us is the env, not config,
+            // and `withNX()` creates a new config object anyway.
+            config = {};
+        }
         for (const plugin of plugins) {
             const fn = await plugin;
             config = await fn(config, ctx);
         }
         return config;
-    };
+    }, {
+        [exports.nxWebpackComposablePlugin]: true,
+    });
 }
 exports.composePlugins = composePlugins;
 function composePluginsSync(...plugins) {
-    return function combined(config, ctx) {
+    return Object.assign(function combined(config, ctx) {
         for (const plugin of plugins) {
             config = plugin(config, ctx);
         }
         return config;
-    };
+    }, {
+        [exports.nxWebpackComposablePlugin]: true,
+    });
 }
 exports.composePluginsSync = composePluginsSync;
+function ensureNxWebpackExecutionContext(ctx) {
+    const projectName = process.env.NX_TASK_TARGET_PROJECT;
+    const targetName = process.env.NX_TASK_TARGET_TARGET;
+    const configurationName = process.env.NX_TASK_TARGET_CONFIGURATION;
+    const projectGraph = (0, devkit_1.readCachedProjectGraph)();
+    const projectNode = projectGraph.nodes[projectName];
+    ctx.options ??= {
+        root: devkit_1.workspaceRoot,
+        projectRoot: projectNode.data.root,
+        sourceRoot: projectNode.data.sourceRoot ?? projectNode.data.root,
+        // These aren't actually needed since NxWebpackPlugin and withNx both support them being undefined.
+        assets: undefined,
+        outputPath: undefined,
+        tsConfig: undefined,
+        outputFileName: undefined,
+    };
+    ctx.context ??= {
+        projectName,
+        targetName,
+        configurationName,
+        cwd: process.cwd(),
+        root: devkit_1.workspaceRoot,
+        isVerbose: process.env['NX_VERBOSE_LOGGING'] === 'true',
+    };
+}

package/src/utils/ensure-dependencies.d.ts

@@ -0,0 +1,6 @@
+import { type GeneratorCallback, type Tree } from '@nx/devkit';
+export type EnsureDependenciesOptions = {
+    compiler?: 'swc' | 'tsc';
+    uiFramework?: 'none' | 'react';
+};
+export declare function ensureDependencies(tree: Tree, options: EnsureDependenciesOptions): GeneratorCallback;

package/src/utils/ensure-dependencies.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureDependencies = void 0;
+const devkit_1 = require("@nx/devkit");
+const add_swc_dependencies_1 = require("@nx/js/src/utils/swc/add-swc-dependencies");
+const versions_1 = require("./versions");
+function ensureDependencies(tree, options) {
+    const tasks = [];
+    const devDependencies = {};
+    if (options.compiler === 'swc') {
+        devDependencies['swc-loader'] = versions_1.swcLoaderVersion;
+        const addSwcTask = (0, add_swc_dependencies_1.addSwcDependencies)(tree);
+        tasks.push(addSwcTask);
+    }
+    if (options.compiler === 'tsc') {
+        devDependencies['tslib'] = versions_1.tsLibVersion;
+    }
+    if (options.uiFramework === 'react') {
+        devDependencies['@pmmmwh/react-refresh-webpack-plugin'] =
+            versions_1.reactRefreshWebpackPluginVersion;
+        devDependencies['@svgr/webpack'] = versions_1.svgrWebpackVersion;
+        devDependencies['react-refresh'] = versions_1.reactRefreshVersion;
+        devDependencies['url-loader'] = versions_1.urlLoaderVersion;
+    }
+    tasks.push((0, devkit_1.addDependenciesToPackageJson)(tree, {}, devDependencies));
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+exports.ensureDependencies = ensureDependencies;

package/src/utils/get-client-environment.js

@@ -1,12 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getClientEnvironment = void 0;
+// Prevent sensitive keys from being bundled when source code uses entire `process.env` object rather than individual keys (e.g. `process.env.NX_FOO`).
+// TODO(v19): Only env vars prefixed with NX_PUBLIC should be bundled. This is a breaking change so we won't do it in v18.
+const excludedKeys = ['NX_CLOUD_ACCESS_TOKEN', 'NX_CLOUD_ENCRYPTION_KEY'];
 function getClientEnvironment(mode) {
     // Grab NODE_ENV and NX_* environment variables and prepare them to be
     // injected into the application via DefinePlugin in webpack configuration.
     const NX_APP = /^NX_/i;
     const raw = Object.keys(process.env)
-        .filter((key) => NX_APP.test(key))
+        .filter((key) => !excludedKeys.includes(key) && NX_APP.test(key))
         .reduce((env, key) => {
         env[key] = process.env[key];
         return env;

package/src/utils/has-plugin.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export declare function hasPlugin(tree: Tree): boolean;

package/src/utils/has-plugin.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasPlugin = void 0;
+const devkit_1 = require("@nx/devkit");
+function hasPlugin(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    return !!nxJson.plugins?.some((p) => typeof p === 'string'
+        ? p === '@nx/webpack/plugin'
+        : p.plugin === '@nx/webpack/plugin');
+}
+exports.hasPlugin = hasPlugin;

package/src/utils/module-federation/dependencies.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDependentPackagesForProject = void 0;
 const typescript_1 = require("./typescript");
+const devkit_1 = require("@nx/devkit");
 function getDependentPackagesForProject(projectGraph, name) {
     const { npmPackages, workspaceLibraries } = collectDependencies(projectGraph, name);
     return {
@@ -34,11 +35,22 @@ function collectDependencies(projectGraph, name, dependencies = {
     return dependencies;
 }
 function getLibraryImportPath(library, projectGraph) {
+    let buildLibsFromSource = true;
+    if (process.env.NX_BUILD_LIBS_FROM_SOURCE) {
+        buildLibsFromSource = process.env.NX_BUILD_LIBS_FROM_SOURCE === 'true';
+    }
+    const libraryNode = projectGraph.nodes[library];
+    let sourceRoots = [libraryNode.data.sourceRoot];
+    if (!buildLibsFromSource && process.env.NX_BUILD_TARGET) {
+        const buildTarget = (0, devkit_1.parseTargetString)(process.env.NX_BUILD_TARGET, projectGraph);
+        sourceRoots = (0, devkit_1.getOutputsForTargetAndConfiguration)(buildTarget, {}, libraryNode);
+    }
     const tsConfigPathMappings = (0, typescript_1.readTsPathMappings)();
-    const sourceRoot = projectGraph.nodes[library].data.sourceRoot;
     for (const [key, value] of Object.entries(tsConfigPathMappings)) {
-        if (value.find((path) => path.startsWith(sourceRoot))) {
-            return key;
+        for (const src of sourceRoots) {
+            if (value.find((path) => path.startsWith(src))) {
+                return key;
+            }
         }
     }
     return undefined;

package/src/utils/module-federation/get-remotes-for-host.js

@@ -18,7 +18,7 @@ function extractRemoteProjectsFromConfig(config, pathToManifestFile) {
             // }
             const parsedManifest = JSON.parse(moduleFederationManifestJson);
             if (Object.keys(parsedManifest).every((key) => typeof key === 'string' && typeof parsedManifest[key] === 'string')) {
-                remotes.push(Object.keys(parsedManifest));
+                remotes.push(...Object.keys(parsedManifest));
             }
         }
     }
@@ -55,7 +55,7 @@ function getRemotes(devRemotes, skipRemotes, config, context, pathToManifestFile
             : (0, find_matching_projects_1.findMatchingProjects)([devRemotes], context.projectGraph.nodes));
     const staticRemotes = knownRemotes.filter((r) => !devServeApps.has(r));
     const devServeRemotes = knownRemotes.filter((r) => devServeApps.has(r));
-    const remotePorts = knownRemotes.map((r) => context.projectGraph.nodes[r].data.targets['serve'].options.port);
+    const remotePorts = devServeRemotes.map((r) => context.projectGraph.nodes[r].data.targets['serve'].options.port);
     return {
         staticRemotes,
         devRemotes: devServeRemotes,

package/src/utils/module-federation/remotes.js

@@ -39,7 +39,7 @@ function handleArrayRemote(remote, remoteEntryExt, isRemoteGlobal) {
         : '';
     // if the remote is defined with anything other than http then we assume it's a promise based remote
     // In that case we should use what the user provides as the remote location
-    if (remoteLocation.startsWith('http')) {
+    if (!remoteLocation.startsWith('promise new Promise')) {
         return `${globalPrefix}${baseRemote}/remoteEntry.${remoteEntryExt}`;
     }
     else {

package/src/utils/module-federation/secondary-entry-points.js

@@ -6,7 +6,7 @@ const fs_1 = require("fs");
 const devkit_1 = require("@nx/devkit");
 const nx_1 = require("@nx/devkit/nx");
 let { readModulePackageJson } = (0, nx_1.requireNx)();
-// TODO: Remove this in Nx 18 when Nx 16.7.0 is no longer supported
+// TODO: Remove this in Nx 19 when Nx 16.7.0 is no longer supported
 readModulePackageJson =
     readModulePackageJson ??
         require('nx/src/utils/package-json').readModulePackageJson;

package/src/utils/module-federation/typescript.js

@@ -4,18 +4,23 @@ exports.getRootTsConfigPath = exports.readTsConfig = exports.readTsPathMappings
 const fs_1 = require("fs");
 const path_1 = require("path");
 const devkit_1 = require("@nx/devkit");
-let tsConfig;
-let tsPathMappings;
+let tsConfig = new Map();
+let tsPathMappings = new Map();
 function readTsPathMappings(tsConfigPath = process.env.NX_TSCONFIG_PATH ?? getRootTsConfigPath()) {
-    if (tsPathMappings) {
-        return tsPathMappings;
+    if (tsPathMappings.has(tsConfigPath)) {
+        return tsPathMappings.get(tsConfigPath);
     }
-    tsConfig ??= readTsConfiguration(tsConfigPath);
-    tsPathMappings = {};
-    Object.entries(tsConfig.options?.paths ?? {}).forEach(([alias, paths]) => {
-        tsPathMappings[alias] = paths.map((path) => path.replace(/^\.\//, ''));
+    if (!tsConfig.has(tsConfigPath)) {
+        tsConfig.set(tsConfigPath, readTsConfiguration(tsConfigPath));
+    }
+    tsPathMappings.set(tsConfigPath, {});
+    Object.entries(tsConfig.get(tsConfigPath).options?.paths ?? {}).forEach(([alias, paths]) => {
+        tsPathMappings.set(tsConfigPath, {
+            ...tsPathMappings.get(tsConfigPath),
+            [alias]: paths.map((path) => path.replace(/^\.\//, '')),
+        });
     });
-    return tsPathMappings;
+    return tsPathMappings.get(tsConfigPath);
 }
 exports.readTsPathMappings = readTsPathMappings;
 function readTsConfiguration(tsConfigPath) {

package/src/utils/versions.d.ts

@@ -1,6 +1,7 @@
 export declare const nxVersion: any;
 export declare const swcLoaderVersion = "0.1.15";
 export declare const tsLibVersion = "^2.3.0";
+export declare const webpackCliVersion = "^5.1.4";
 export declare const reactRefreshWebpackPluginVersion = "^0.5.7";
 export declare const svgrWebpackVersion = "^8.0.1";
 export declare const reactRefreshVersion = "^0.10.0";

package/src/utils/versions.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.urlLoaderVersion = exports.reactRefreshVersion = exports.svgrWebpackVersion = exports.reactRefreshWebpackPluginVersion = exports.tsLibVersion = exports.swcLoaderVersion = exports.nxVersion = void 0;
+exports.urlLoaderVersion = exports.reactRefreshVersion = exports.svgrWebpackVersion = exports.reactRefreshWebpackPluginVersion = exports.webpackCliVersion = exports.tsLibVersion = exports.swcLoaderVersion = exports.nxVersion = void 0;
 exports.nxVersion = require('../../package.json').version;
 exports.swcLoaderVersion = '0.1.15';
 exports.tsLibVersion = '^2.3.0';
+exports.webpackCliVersion = '^5.1.4';
 // React apps
 exports.reactRefreshWebpackPluginVersion = '^0.5.7';
 exports.svgrWebpackVersion = '^8.0.1';

package/src/utils/webpack/deprecated-stylus-loader.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const devkit_1 = require("@nx/devkit");
 // @ts-ignore
 const stylusLoader = require("stylus-loader");
-// TOOD(v18): Remove this file and stylus support.
+// TOOD(v19): Remove this file and stylus support.
 function default_1(source) {
-    devkit_1.logger.warn(`Stylus is support is deprecated and will be removed in Nx 18. We recommend that you migrate to Sass by renaming \`.styl\` files to \`.scss\` and ensuring that the content is valid Sass.`);
+    devkit_1.logger.warn(`Stylus is support is deprecated and will be removed in Nx 19. We recommend that you migrate to Sass by renaming \`.styl\` files to \`.scss\` and ensuring that the content is valid Sass.`);
     return stylusLoader.call(this, source);
 }
 exports.default = default_1;

package/src/utils/webpack/interpolate-env-variables-to-index.js

@@ -7,8 +7,11 @@ function interpolateEnvironmentVariablesToIndex(contents, deployUrl) {
 }
 exports.interpolateEnvironmentVariablesToIndex = interpolateEnvironmentVariablesToIndex;
 const NX_PREFIX = /^NX_/i;
+// Prevent sensitive keys from being bundled when source code uses entire `process.env` object rather than individual keys (e.g. `process.env.NX_FOO`).
+// TODO(v19): Only env vars prefixed with NX_PUBLIC should be bundled. This is a breaking change so we won't do it in v18.
+const excludedKeys = ['NX_CLOUD_ACCESS_TOKEN', 'NX_CLOUD_ENCRYPTION_KEY'];
 function isNxEnvironmentKey(x) {
-    return NX_PREFIX.test(x);
+    return !excludedKeys.includes(x) && NX_PREFIX.test(x);
 }
 function getClientEnvironment(deployUrl) {
     return Object.keys(process.env)

package/src/utils/webpack/plugins/postcss-cli-resources.js

@@ -122,7 +122,7 @@ function PostcssCliResources(options) {
             const resourceCache = new Map();
             return Promise.all(urlDeclarations.map(async (decl) => {
                 const value = decl.value;
-                const urlRegex = /url\(\s*(?:"([^"]+)"|'([^']+)'|(.+?))\s*\)/g;
+                const urlRegex = /url(?:\(\s*(['"]?))(.*?)(?:\1\s*\))/g;
                 const segments = [];
                 let match;
                 let lastIndex = 0;
@@ -131,7 +131,7 @@ function PostcssCliResources(options) {
                 const inputFile = decl.source && decl.source.input.file;
                 const context = (inputFile && path.dirname(inputFile)) || loader.context;
                 while ((match = urlRegex.exec(value))) {
-                    const originalUrl = match[1] || match[2] || match[3];
+                    const originalUrl = match[2];
                     let processedUrl;
                     try {
                         processedUrl = await process(originalUrl, context, resourceCache);

package/src/utils/webpack/read-webpack-options.d.ts

@@ -0,0 +1,10 @@
+import { Configuration } from 'webpack';
+/**
+ * Reads the webpack options from a give webpack configuration. The configuration can be:
+ * 1. A standard config object
+ * 2. A standard function that returns a config object (webpack.js.org/configuration/configuration-types/#exporting-a-function)
+ * 3. A Nx-specific composable function that takes Nx context, webpack config, and returns the config object.
+ *
+ * @param webpackConfig
+ */
+export declare function readWebpackOptions(webpackConfig: unknown): Promise<Configuration>;

package/src/utils/webpack/read-webpack-options.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readWebpackOptions = void 0;
+const devkit_1 = require("@nx/devkit");
+const config_1 = require("../config");
+/**
+ * Reads the webpack options from a give webpack configuration. The configuration can be:
+ * 1. A standard config object
+ * 2. A standard function that returns a config object (webpack.js.org/configuration/configuration-types/#exporting-a-function)
+ * 3. A Nx-specific composable function that takes Nx context, webpack config, and returns the config object.
+ *
+ * @param webpackConfig
+ */
+async function readWebpackOptions(webpackConfig) {
+    let config;
+    if ((0, config_1.isNxWebpackComposablePlugin)(webpackConfig)) {
+        config = await webpackConfig({}, {
+            // These values are only used during build-time, so passing stubs here just to read out
+            // the returned config object.
+            options: {
+                root: devkit_1.workspaceRoot,
+                projectRoot: '',
+                sourceRoot: '',
+                outputFileName: undefined,
+                outputPath: undefined,
+                assets: undefined,
+            },
+            context: { root: devkit_1.workspaceRoot, cwd: undefined, isVerbose: false },
+        });
+    }
+    else if (typeof webpackConfig === 'function') {
+        config = await webpackConfig({
+            production: true, // we want the production build options
+        }, {});
+    }
+    else {
+        config = webpackConfig;
+    }
+    return config;
+}
+exports.readWebpackOptions = readWebpackOptions;

package/src/utils/webpack/resolve-user-defined-webpack-config.d.ts

@@ -0,0 +1,3 @@
+export declare function resolveUserDefinedWebpackConfig(path: string, tsConfig: string, 
+/** Skip require cache and return latest content */
+reload?: boolean): any;

package/src/utils/webpack/{custom-webpack.js → resolve-user-defined-webpack-config.js}

@@ -1,8 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isRegistered = exports.resolveCustomWebpackConfig = void 0;
+exports.resolveUserDefinedWebpackConfig = void 0;
 const internal_1 = require("@nx/js/src/internal");
-function resolveCustomWebpackConfig(path, tsConfig) {
+function resolveUserDefinedWebpackConfig(path, tsConfig, 
+/** Skip require cache and return latest content */
+reload = false) {
+    if (reload) {
+        // Clear cache if the path is in the cache
+        if (require.cache[path]) {
+            // Clear all entries because config may import other modules
+            for (const k of Object.keys(require.cache)) {
+                delete require.cache[k];
+            }
+        }
+    }
     // Don't transpile non-TS files. This prevents workspaces libs from being registered via tsconfig-paths.
     // There's an issue here with Nx workspace where loading plugins from source (via tsconfig-paths) can lead to errors.
     if (!/\.(ts|mts|cts)$/.test(path)) {
@@ -25,9 +36,4 @@ function resolveCustomWebpackConfig(path, tsConfig) {
         : maybeCustomWebpackConfig;
     return customWebpackConfig;
 }
-exports.resolveCustomWebpackConfig = resolveCustomWebpackConfig;
-function isRegistered() {
-    return (require.extensions['.ts'] != undefined ||
-        require.extensions['.tsx'] != undefined);
-}
-exports.isRegistered = isRegistered;
+exports.resolveUserDefinedWebpackConfig = resolveUserDefinedWebpackConfig;

package/src/utils/with-nx.d.ts

@@ -1,62 +1,8 @@
-import { NormalizedWebpackExecutorOptions } from '../executors/webpack/schema';
-import { NxWebpackPlugin } from './config';
-export interface WithNxOptions {
-    skipTypeChecking?: boolean;
-}
+import { NxComposableWebpackPlugin } from './config';
+import { NxWebpackPluginOptions } from '../plugins/nx-webpack-plugin/nx-webpack-plugin-options';
+export type WithNxOptions = Partial<NxWebpackPluginOptions>;
 /**
  * @param {WithNxOptions} pluginOptions
  * @returns {NxWebpackPlugin}
  */
-export declare function withNx(pluginOptions?: WithNxOptions): NxWebpackPlugin;
-export declare function createLoaderFromCompiler(options: NormalizedWebpackExecutorOptions): {
-    test: RegExp;
-    loader: string;
-    exclude: RegExp;
-    options: {
-        cwd: string;
-        emitDecoratorMetadata: boolean;
-        isModern: boolean;
-        isTest: boolean;
-        envName: string;
-        cacheDirectory: boolean;
-        cacheCompression: boolean;
-    };
-} | {
-    test: RegExp;
-    loader: string;
-    exclude: RegExp;
-    options: {
-        jsc: {
-            parser: {
-                syntax: string;
-                decorators: boolean;
-                tsx: boolean;
-            };
-            transform: {
-                react: {
-                    runtime: string;
-                };
-            };
-            loose: boolean;
-        };
-        configFile?: undefined;
-        transpileOnly?: undefined;
-        experimentalWatchApi?: undefined;
-        getCustomTransformers?: undefined;
-    };
-} | {
-    test: RegExp;
-    loader: string;
-    exclude: RegExp;
-    options: {
-        configFile: string;
-        transpileOnly: boolean;
-        experimentalWatchApi: boolean;
-        getCustomTransformers: (program: any) => {
-            before: any;
-            after: any;
-            afterDeclarations: any;
-        };
-        jsc?: undefined;
-    };
-};
+export declare function withNx(pluginOptions?: WithNxOptions): NxComposableWebpackPlugin;