@nx/webpack 17.2.0-beta.0 → 17.2.0-beta.10

package/src/plugins/nx-webpack-plugin/nx-webpack-plugin-options.d.ts

@@ -30,48 +30,177 @@ export interface OptimizationOptions {
     styles: boolean;
 }
 export interface NxWebpackPluginOptions {
-    main: string;
-    outputPath: string;
-    tsConfig: string;
+    /**
+     * The tsconfig file for the project. e.g. `tsconfig.json`
+     */
+    tsConfig?: string;
+    /**
+     * The entry point for the bundle. e.g. `src/main.ts`
+     */
+    main?: string;
+    /**
+     * Secondary entry points for the bundle.
+     */
     additionalEntryPoints?: AdditionalEntryPoint[];
+    /**
+     * Assets to be copied over to the output path.
+     */
     assets?: Array<AssetGlob | string>;
+    /**
+     * Babel configuration file if compiler is babel.
+     */
     babelConfig?: string;
+    /**
+     * If true, Babel will look for a babel.config.json up the directory tree.
+     */
     babelUpwardRootMode?: boolean;
+    /**
+     * Set <base href> for the resulting index.html.
+     */
     baseHref?: string;
     commonChunk?: boolean;
+    /**
+     * The compiler to use. Default is `babel` and requires a `.babelrc` file.
+     */
     compiler?: 'babel' | 'swc' | 'tsc';
+    /**
+     * Set `crossorigin` attribute on the `script` and `link` tags.
+     */
     crossOrigin?: 'none' | 'anonymous' | 'use-credentials';
+    /**
+     * Delete the output path before building.
+     */
     deleteOutputPath?: boolean;
+    /**
+     * The deploy path for the application. e.g. `/my-app/`
+     */
     deployUrl?: string;
+    /**
+     * Define external packages that will not be bundled.
+     * Use `all` to exclude all 3rd party packages, and `none` to bundle all packages.
+     * Use an array to exclude specific packages from the bundle.
+     * Default is `none`.
+     */
     externalDependencies?: 'all' | 'none' | string[];
+    /**
+     * Extract CSS as an external file. Default is `true`.
+     */
     extractCss?: boolean;
+    /**
+     * Extract licenses from 3rd party modules and add them to the output.
+     */
     extractLicenses?: boolean;
+    /**
+     * Replace files at build time. e.g. `[{ "replace": "src/a.dev.ts", "with": "src/a.prod.ts" }]`
+     */
     fileReplacements?: FileReplacement[];
+    /**
+     * Generate an `index.html` file if `index.html` is passed. Default is `true`
+     */
     generateIndexHtml?: boolean;
+    /**
+     * Generate a `package.json` file for the bundle. Useful for Node applications.
+     */
     generatePackageJson?: boolean;
+    /**
+     * Path to the `index.html`.
+     */
     index?: string;
+    /**
+     * Set the memory limit for the type-checking process. Default is `2048`.
+     */
     memoryLimit?: number;
+    /**
+     * Use the source file name in output chunks. Useful for development or for Node.
+     */
     namedChunks?: boolean;
+    /**
+     * Optimize the bundle using Terser.
+     */
     optimization?: boolean | OptimizationOptions;
+    /**
+     * Specify the output filename for the bundle. Useful for Node applications that use `@nx/js:node` to serve.
+     */
     outputFileName?: string;
+    /**
+     * Use file hashes in the output filenames. Recommended for production web applications.
+     */
     outputHashing?: any;
+    /**
+     * Override `output.path` in webpack configuration. This setting is not recommended and exists for backwards compatibility.
+     */
+    outputPath?: string;
+    /**
+     * Override `watchOptions.poll` in webpack configuration. This setting is not recommended and exists for backwards compatibility.
+     */
     poll?: number;
+    /**
+     * The polyfill file to use. Useful for supporting legacy browsers. e.g. `src/polyfills.ts`
+     */
     polyfills?: string;
+    /**
+     * Manually set the PostCSS configuration file. By default, PostCSS will look for `postcss.config.js` in the directory.
+     */
     postcssConfig?: string;
+    /**
+     * Display build progress in the terminal.
+     */
     progress?: boolean;
+    /**
+     * Add an additional chunk for the Webpack runtime. Defaults to `true` when `target === 'web'`.
+     */
     runtimeChunk?: boolean;
+    /**
+     * External scripts that will be included before the main application entry.
+     */
     scripts?: Array<ExtraEntryPointClass | string>;
+    /**
+     * Skip type checking. Default is `false`.
+     */
     skipTypeChecking?: boolean;
+    /**
+     * Generate source maps.
+     */
     sourceMap?: boolean | 'hidden';
+    /**
+     * When `true`, `process.env.NODE_ENV` will be excluded from the bundle. Useful for building a web application to run in a Node environment.
+     */
     ssr?: boolean;
+    /**
+     * Generate a `stats.json` file which can be analyzed using tools such as `webpack-bundle-analyzer`.
+     */
     statsJson?: boolean;
+    /**
+     * Options for the style preprocessor. e.g. `{ "includePaths": [] }` for SASS.
+     */
     stylePreprocessorOptions?: any;
+    /**
+     * External stylesheets that will be included with the application.
+     */
     styles?: Array<ExtraEntryPointClass | string>;
+    /**
+     * Enables the use of subresource integrity validation.
+     */
     subresourceIntegrity?: boolean;
+    /**
+     * Override the `target` option in webpack configuration. This setting is not recommended and exists for backwards compatibility.
+     */
     target?: string | string[];
+    /**
+     * List of TypeScript Compiler Transformers Plugins.
+     */
     transformers?: TransformerEntry[];
+    /**
+     * Generate a separate vendor chunk for 3rd party packages.
+     */
     vendorChunk?: boolean;
+    /**
+     * Log additional information for debugging purposes.
+     */
     verbose?: boolean;
+    /**
+     * Watch for file changes.
+     */
     watch?: boolean;
 }
 export interface NormalizedNxWebpackPluginOptions extends NxWebpackPluginOptions {

package/src/plugins/nx-webpack-plugin/nx-webpack-plugin.d.ts

@@ -12,7 +12,6 @@ import { NxWebpackPluginOptions } from './nx-webpack-plugin-options';
  */
 export declare class NxWebpackPlugin {
     private readonly options;
-    constructor(options: NxWebpackPluginOptions);
+    constructor(options?: NxWebpackPluginOptions);
     apply(compiler: Compiler): void;
-    private readExecutorOptions;
 }

package/src/plugins/nx-webpack-plugin/nx-webpack-plugin.js

@@ -16,21 +16,19 @@ const apply_web_config_1 = require("./lib/apply-web-config");
  * Web-only features, such as stylesheets and images, are only supported when `target` is 'web' or 'webworker'.
  */
 class NxWebpackPlugin {
-    constructor(options) {
-        this.options = (0, normalize_options_1.normalizeOptions)({
-            ...options,
-            ...this.readExecutorOptions(),
-        });
+    constructor(options = {}) {
+        // If we're not in an Nx task, we're building inferred targets, so skip normalizing build options.
+        if (process.env['NX_TASK_TARGET_PROJECT']) {
+            this.options = (0, normalize_options_1.normalizeOptions)(options);
+        }
     }
     apply(compiler) {
-        const target = this.options.target ?? compiler.options.target;
+        // Defaults to 'web' if not specified to match Webpack's default.
+        const target = this.options.target ?? compiler.options.target ?? 'web';
         this.options.outputPath ??= compiler.options.output?.path;
         if (typeof target === 'string') {
             this.options.target = target;
         }
-        if (this.options.deleteOutputPath) {
-            (0, fs_1.deleteOutputDir)(this.options.root, this.options.outputPath);
-        }
         (0, apply_base_config_1.applyBaseConfig)(this.options, compiler.options, {
             useNormalizedEntry: true,
         });
@@ -42,14 +40,8 @@ class NxWebpackPlugin {
                 useNormalizedEntry: true,
             });
         }
-    }
-    readExecutorOptions() {
-        const fromExecutor = process.env['NX_WEBPACK_EXECUTOR_RAW_OPTIONS'] ?? '{}';
-        try {
-            return JSON.parse(fromExecutor);
-        }
-        catch {
-            return {};
+        if (this.options.deleteOutputPath) {
+            (0, fs_1.deleteOutputDir)(this.options.root, this.options.outputPath);
         }
     }
 }

package/src/plugins/plugin.d.ts

@@ -0,0 +1,9 @@
+import { CreateDependencies, CreateNodes } from '@nx/devkit';
+export interface WebpackPluginOptions {
+    buildTargetName?: string;
+    serveTargetName?: string;
+    staticServeTargetName?: string;
+    previewTargetName?: string;
+}
+export declare const createDependencies: CreateDependencies;
+export declare const createNodes: CreateNodes<WebpackPluginOptions>;

package/src/plugins/plugin.js

@@ -0,0 +1,127 @@
+"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 project_configuration_utils_1 = require("nx/src/project-graph/utils/project-configuration-utils");
+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,mts,cjs,cts}',
+    async (configFilePath, options, context) => {
+        options ??= {};
+        options.buildTargetName ??= 'build';
+        options.serveTargetName ??= 'serve';
+        options.staticServeTargetName ??= 'static-serve';
+        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)());
+    const webpackOptions = await (0, read_webpack_options_1.readWebpackOptions)(webpackConfig);
+    const outputPath = normalizeOutputPath(webpackOptions.output?.path) ??
+        '{workspaceRoot}/dist/{projectRoot}';
+    const targets = {};
+    const configBasename = (0, path_1.basename)(configFilePath);
+    targets[options.buildTargetName] = {
+        command: `webpack -c ${configBasename} --node-env=production`,
+        options: {
+            cwd: projectRoot,
+        },
+    };
+    const buildTargetDefaults = (0, project_configuration_utils_1.readTargetDefaultsForTarget)(options.buildTargetName, context.nxJsonConfiguration.targetDefaults);
+    if (buildTargetDefaults?.cache === undefined) {
+        targets[options.buildTargetName].cache = true;
+    }
+    if (buildTargetDefaults?.inputs === undefined) {
+        targets[options.buildTargetName].inputs =
+            'production' in namedInputs
+                ? [
+                    'default',
+                    '^production',
+                    {
+                        externalDependencies: ['webpack-cli'],
+                    },
+                ]
+                : [
+                    'default',
+                    '^default',
+                    {
+                        externalDependencies: ['webpack-cli'],
+                    },
+                ];
+    }
+    if (buildTargetDefaults?.outputs === undefined) {
+        targets[options.buildTargetName].outputs = [outputPath];
+    }
+    targets[options.serveTargetName] = {
+        command: `webpack serve -c ${configBasename} --node-env=development`,
+        options: {
+            cwd: projectRoot,
+        },
+    };
+    targets[options.previewTargetName] = {
+        command: `webpack serve -c ${configBasename} --node-env=production`,
+        options: {
+            cwd: projectRoot,
+        },
+    };
+    targets[options.staticServeTargetName] = {
+        executor: '@nx/web:file-server',
+        options: {
+            buildTarget: `${projectRoot}:${options.buildTargetName}`,
+        },
+    };
+    return targets;
+}
+function normalizeOutputPath(outputPath) {
+    if (!outputPath)
+        return undefined;
+    if ((0, path_1.isAbsolute)(outputPath)) {
+        return `{workspaceRoot}/${(0, path_1.relative)(devkit_1.workspaceRoot, outputPath)}`;
+    }
+    else {
+        return 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/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/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/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 @@
+export declare function resolveUserDefinedWebpackConfig(path: string, tsConfig: string): any;

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

@@ -1,8 +1,8 @@
 "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) {
     // 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 +25,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,9 +1,8 @@
-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 withNx(pluginOptions?: WithNxOptions): NxComposableWebpackPlugin;

package/src/utils/with-nx.js

@@ -2,18 +2,24 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.withNx = void 0;
 const apply_base_config_1 = require("../plugins/nx-webpack-plugin/lib/apply-base-config");
+const normalize_options_1 = require("../plugins/nx-webpack-plugin/lib/normalize-options");
 const processed = new Set();
 /**
  * @param {WithNxOptions} pluginOptions
  * @returns {NxWebpackPlugin}
  */
-function withNx(pluginOptions) {
+function withNx(pluginOptions = {}) {
     return function configure(config, { options, context }) {
         if (processed.has(config))
             return config;
         (0, apply_base_config_1.applyBaseConfig)({
             ...options,
             ...pluginOptions,
+            assets: options.assets
+                ? options.assets
+                : pluginOptions.assets
+                    ? (0, normalize_options_1.normalizeAssets)(pluginOptions.assets, options.root, options.sourceRoot)
+                    : [],
             root: context.root,
             projectName: context.projectName,
             targetName: context.targetName,

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

@@ -1,4 +1,4 @@
-import { NxWebpackPlugin } from './config';
+import { NxComposableWebpackPlugin } from './config';
 import { ExtraEntryPointClass, NormalizedWebpackExecutorOptions } from '../executors/webpack/schema';
 export interface WithWebOptions {
     baseHref?: string;
@@ -19,4 +19,4 @@ export type MergedOptions = Omit<NormalizedWebpackExecutorOptions, keyof WithWeb
  * @param {WithWebOptions} pluginOptions
  * @returns {NxWebpackPlugin}
  */
-export declare function withWeb(pluginOptions?: WithWebOptions): NxWebpackPlugin;
+export declare function withWeb(pluginOptions?: WithWebOptions): NxComposableWebpackPlugin;

package/src/executors/webpack/lib/get-webpack-config.d.ts

@@ -1,5 +0,0 @@
-import type { Configuration } from 'webpack';
-import { ExecutorContext } from '@nx/devkit';
-import { NormalizedWebpackExecutorOptions } from '../schema';
-/** @deprecated Use withNx, withWeb, or withReact */
-export declare function getWebpackConfig(context: ExecutorContext, options: NormalizedWebpackExecutorOptions): Configuration;