@nx/webpack 0.0.0-pr-22179-271588f

package/src/plugins/plugin.js

@@ -0,0 +1,131 @@
+"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,
+        },
+    };
+    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/plugins/stats-json-plugin.d.ts

@@ -0,0 +1,4 @@
+import { Compiler } from 'webpack';
+export declare class StatsJsonPlugin {
+    apply(compiler: Compiler): void;
+}

package/src/plugins/stats-json-plugin.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatsJsonPlugin = void 0;
+const webpack_1 = require("webpack");
+class StatsJsonPlugin {
+    apply(compiler) {
+        compiler.hooks.emit.tap('StatsJsonPlugin', (compilation) => {
+            const data = JSON.stringify(compilation.getStats().toJson('verbose'));
+            compilation.assets[`stats.json`] = new webpack_1.sources.RawSource(data);
+        });
+    }
+}
+exports.StatsJsonPlugin = StatsJsonPlugin;

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

@@ -0,0 +1,11 @@
+import type { Compiler } from 'webpack';
+export declare class WebpackNxBuildCoordinationPlugin {
+    private readonly buildCmd;
+    private currentlyRunning;
+    private buildCmdProcess;
+    constructor(buildCmd: string, skipInitialBuild?: boolean);
+    apply(compiler: Compiler): void;
+    startWatchingBuildableLibs(): Promise<void>;
+    buildChangedProjects(): Promise<void>;
+    private createFileWatcher;
+}

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

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebpackNxBuildCoordinationPlugin = void 0;
+const child_process_1 = require("child_process");
+const client_1 = require("nx/src/daemon/client/client");
+const watch_1 = require("nx/src/command-line/watch");
+const output_1 = require("nx/src/utils/output");
+class WebpackNxBuildCoordinationPlugin {
+    constructor(buildCmd, skipInitialBuild) {
+        this.buildCmd = buildCmd;
+        this.currentlyRunning = 'none';
+        this.buildCmdProcess = null;
+        if (!skipInitialBuild) {
+            this.buildChangedProjects();
+        }
+        this.startWatchingBuildableLibs();
+    }
+    apply(compiler) {
+        compiler.hooks.beforeCompile.tapPromise('IncrementalDevServerPlugin', async () => {
+            while (this.currentlyRunning === 'nx-build') {
+                await sleep(50);
+            }
+            this.currentlyRunning = 'webpack-build';
+        });
+        compiler.hooks.done.tapPromise('IncrementalDevServerPlugin', async () => {
+            this.currentlyRunning = 'none';
+        });
+    }
+    async startWatchingBuildableLibs() {
+        const unregisterFileWatcher = await this.createFileWatcher();
+        process.on('exit', () => {
+            unregisterFileWatcher();
+        });
+    }
+    async buildChangedProjects() {
+        while (this.currentlyRunning === 'webpack-build') {
+            await sleep(50);
+        }
+        this.currentlyRunning = 'nx-build';
+        try {
+            return await new Promise((res) => {
+                this.buildCmdProcess = (0, child_process_1.exec)(this.buildCmd);
+                this.buildCmdProcess.stdout.pipe(process.stdout);
+                this.buildCmdProcess.stderr.pipe(process.stderr);
+                this.buildCmdProcess.on('exit', () => {
+                    res();
+                });
+                this.buildCmdProcess.on('error', () => {
+                    res();
+                });
+            });
+        }
+        finally {
+            this.currentlyRunning = 'none';
+            this.buildCmdProcess = null;
+        }
+    }
+    createFileWatcher() {
+        const runner = new watch_1.BatchFunctionRunner(() => this.buildChangedProjects());
+        return client_1.daemonClient.registerFileWatcher({
+            watchProjects: 'all',
+        }, (err, { changedProjects, changedFiles }) => {
+            if (err === 'closed') {
+                output_1.output.error({
+                    title: 'Watch connection closed',
+                    bodyLines: [
+                        'The daemon has closed the connection to this watch process.',
+                        'Please restart your watch command.',
+                    ],
+                });
+                process.exit(1);
+            }
+            if (this.buildCmdProcess) {
+                this.buildCmdProcess.kill(2);
+                this.buildCmdProcess = null;
+            }
+            // Queue a build
+            runner.enqueue(changedProjects, changedFiles);
+        });
+    }
+}
+exports.WebpackNxBuildCoordinationPlugin = WebpackNxBuildCoordinationPlugin;
+function sleep(time) {
+    return new Promise((resolve) => setTimeout(resolve, time));
+}

package/src/plugins/write-index-html-plugin.d.ts

@@ -0,0 +1,22 @@
+import { Compiler } from 'webpack';
+import { ExtraEntryPoint } from '../utils/models';
+export interface WriteIndexHtmlOptions {
+    indexPath: string;
+    outputPath: string;
+    baseHref?: string;
+    deployUrl?: string;
+    sri?: boolean;
+    scripts?: ExtraEntryPoint[];
+    styles?: ExtraEntryPoint[];
+    crossOrigin?: 'none' | 'anonymous' | 'use-credentials';
+}
+export declare class WriteIndexHtmlPlugin {
+    private readonly options;
+    constructor(options: WriteIndexHtmlOptions);
+    apply(compiler: Compiler): void;
+    private getEmittedFiles;
+    private stripBom;
+    private augmentIndexHtml;
+    private generateSriAttributes;
+    private filterAndMapBuildFiles;
+}

package/src/plugins/write-index-html-plugin.js

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WriteIndexHtmlPlugin = void 0;
+const webpack = require("webpack");
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+const interpolate_env_variables_to_index_1 = require("../utils/webpack/interpolate-env-variables-to-index");
+const package_chunk_sort_1 = require("../utils/webpack/package-chunk-sort");
+const path_1 = require("path");
+const parse5 = require('parse5');
+class WriteIndexHtmlPlugin {
+    constructor(options) {
+        this.options = options;
+    }
+    apply(compiler) {
+        const { outputPath, indexPath, baseHref, deployUrl, sri = false, scripts = [], styles = [], crossOrigin, } = this.options;
+        compiler.hooks.thisCompilation.tap('WriteIndexHtmlPlugin', (compilation) => {
+            compilation.hooks.processAssets.tap({
+                name: 'WriteIndexHtmlPlugin',
+                // After minification and sourcemaps are done
+                stage: webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE,
+            }, () => {
+                const moduleFiles = this.getEmittedFiles(compilation);
+                const files = moduleFiles.filter((x) => x.extension === '.css');
+                let content = (0, fs_1.readFileSync)(indexPath).toString();
+                content = this.stripBom(content);
+                compilation.assets[outputPath] = this.augmentIndexHtml({
+                    input: outputPath,
+                    inputContent: (0, interpolate_env_variables_to_index_1.interpolateEnvironmentVariablesToIndex)(content, deployUrl),
+                    baseHref,
+                    deployUrl,
+                    crossOrigin,
+                    sri,
+                    entrypoints: (0, package_chunk_sort_1.generateEntryPoints)({ scripts, styles }),
+                    files: this.filterAndMapBuildFiles(files, ['.js', '.css']),
+                    moduleFiles: this.filterAndMapBuildFiles(moduleFiles, ['.js']),
+                    loadOutputFile: (filePath) => compilation.assets[filePath].source().toString(),
+                });
+            });
+        });
+    }
+    getEmittedFiles(compilation) {
+        const files = [];
+        // adds all chunks to the list of emitted files such as lazy loaded modules
+        for (const chunk of compilation.chunks) {
+            for (const file of chunk.files) {
+                files.push({
+                    // The id is guaranteed to exist at this point in the compilation process
+                    id: chunk.id.toString(),
+                    name: chunk.name,
+                    file,
+                    extension: (0, path_1.extname)(file),
+                    initial: chunk.isOnlyInitial(),
+                });
+            }
+        }
+        // other all files
+        for (const file of Object.keys(compilation.assets)) {
+            files.push({
+                file,
+                extension: (0, path_1.extname)(file),
+                initial: false,
+                asset: true,
+            });
+        }
+        // dedupe
+        return files.filter(({ file, name }, index) => files.findIndex((f) => f.file === file && (!name || name === f.name)) === index);
+    }
+    stripBom(data) {
+        return data.replace(/^\uFEFF/, '');
+    }
+    augmentIndexHtml(params) {
+        const { loadOutputFile, files, moduleFiles = [], entrypoints } = params;
+        let { crossOrigin = 'none' } = params;
+        if (params.sri && crossOrigin === 'none') {
+            crossOrigin = 'anonymous';
+        }
+        const stylesheets = new Set();
+        const scripts = new Set();
+        // Sort files in the order we want to insert them by entrypoint and dedupes duplicates
+        const mergedFiles = [...moduleFiles, ...files];
+        for (const entrypoint of entrypoints) {
+            for (const { extension, file, name } of mergedFiles) {
+                if (name !== entrypoint) {
+                    continue;
+                }
+                switch (extension) {
+                    case '.js':
+                        scripts.add(file);
+                        break;
+                    case '.css':
+                        stylesheets.add(file);
+                        break;
+                }
+            }
+        }
+        // Find the head and body elements
+        const treeAdapter = parse5.treeAdapters.default;
+        const document = parse5.parse(params.inputContent, {
+            treeAdapter,
+            locationInfo: true,
+        });
+        let headElement;
+        let bodyElement;
+        for (const docChild of document.childNodes) {
+            if (docChild.tagName === 'html') {
+                for (const htmlChild of docChild.childNodes) {
+                    if (htmlChild.tagName === 'head') {
+                        headElement = htmlChild;
+                    }
+                    else if (htmlChild.tagName === 'body') {
+                        bodyElement = htmlChild;
+                    }
+                }
+            }
+        }
+        if (!headElement || !bodyElement) {
+            throw new Error('Missing head and/or body elements');
+        }
+        // Determine script insertion point
+        let scriptInsertionPoint;
+        if (bodyElement.__location && bodyElement.__location.endTag) {
+            scriptInsertionPoint = bodyElement.__location.endTag.startOffset;
+        }
+        else {
+            // Less accurate fallback
+            // parse5 4.x does not provide locations if malformed html is present
+            scriptInsertionPoint = params.inputContent.indexOf('</body>');
+        }
+        let styleInsertionPoint;
+        if (headElement.__location && headElement.__location.endTag) {
+            styleInsertionPoint = headElement.__location.endTag.startOffset;
+        }
+        else {
+            // Less accurate fallback
+            // parse5 4.x does not provide locations if malformed html is present
+            styleInsertionPoint = params.inputContent.indexOf('</head>');
+        }
+        // Inject into the html
+        const indexSource = new webpack.sources.ReplaceSource(new webpack.sources.RawSource(params.inputContent, false), params.input);
+        let scriptElements = '';
+        for (const script of scripts) {
+            const attrs = [
+                { name: 'src', value: (params.deployUrl || '') + script },
+            ];
+            if (crossOrigin !== 'none') {
+                attrs.push({ name: 'crossorigin', value: crossOrigin });
+            }
+            // We want to include nomodule or module when a file is not common amongs all
+            // such as runtime.js
+            const scriptPredictor = ({ file, }) => file === script;
+            if (!files.some(scriptPredictor)) {
+                // in some cases for differential loading file with the same name is avialable in both
+                // nomodule and module such as scripts.js
+                // we shall not add these attributes if that's the case
+                const isModuleType = moduleFiles.some(scriptPredictor);
+                if (isModuleType) {
+                    attrs.push({ name: 'type', value: 'module' });
+                }
+                else {
+                    attrs.push({ name: 'defer', value: null });
+                }
+            }
+            else {
+                attrs.push({ name: 'type', value: 'module' });
+            }
+            if (params.sri) {
+                const content = loadOutputFile(script);
+                attrs.push(...this.generateSriAttributes(content));
+            }
+            const attributes = attrs
+                .map((attr) => attr.value === null ? attr.name : `${attr.name}="${attr.value}"`)
+                .join(' ');
+            scriptElements += `<script ${attributes}></script>`;
+        }
+        indexSource.insert(scriptInsertionPoint, scriptElements);
+        // Adjust base href if specified
+        if (typeof params.baseHref == 'string') {
+            let baseElement;
+            for (const headChild of headElement.childNodes) {
+                if (headChild.tagName === 'base') {
+                    baseElement = headChild;
+                }
+            }
+            const baseFragment = treeAdapter.createDocumentFragment();
+            if (!baseElement) {
+                baseElement = treeAdapter.createElement('base', undefined, [
+                    { name: 'href', value: params.baseHref },
+                ]);
+                treeAdapter.appendChild(baseFragment, baseElement);
+                indexSource.insert(headElement.__location.startTag.endOffset, parse5.serialize(baseFragment, { treeAdapter }));
+            }
+            else {
+                let hrefAttribute;
+                for (const attribute of baseElement.attrs) {
+                    if (attribute.name === 'href') {
+                        hrefAttribute = attribute;
+                    }
+                }
+                if (hrefAttribute) {
+                    hrefAttribute.value = params.baseHref;
+                }
+                else {
+                    baseElement.attrs.push({ name: 'href', value: params.baseHref });
+                }
+                treeAdapter.appendChild(baseFragment, baseElement);
+                indexSource.replace(baseElement.__location.startOffset, baseElement.__location.endOffset, parse5.serialize(baseFragment, { treeAdapter }));
+            }
+        }
+        const styleElements = treeAdapter.createDocumentFragment();
+        for (const stylesheet of stylesheets) {
+            const attrs = [
+                { name: 'rel', value: 'stylesheet' },
+                { name: 'href', value: (params.deployUrl || '') + stylesheet },
+            ];
+            if (crossOrigin !== 'none') {
+                attrs.push({ name: 'crossorigin', value: crossOrigin });
+            }
+            if (params.sri) {
+                const content = loadOutputFile(stylesheet);
+                attrs.push(...this.generateSriAttributes(content));
+            }
+            const element = treeAdapter.createElement('link', undefined, attrs);
+            treeAdapter.appendChild(styleElements, element);
+        }
+        indexSource.insert(styleInsertionPoint, parse5.serialize(styleElements, { treeAdapter }));
+        return indexSource;
+    }
+    generateSriAttributes(content) {
+        const algo = 'sha384';
+        const hash = (0, crypto_1.createHash)(algo).update(content, 'utf8').digest('base64');
+        return [{ name: 'integrity', value: `${algo}-${hash}` }];
+    }
+    filterAndMapBuildFiles(files, extensionFilter) {
+        const filteredFiles = [];
+        // This test excludes files generated by HMR (e.g. main.hot-update.js).
+        const hotUpdateAsset = /hot-update\.[cm]?js$/;
+        for (const { file, name, extension, initial } of files) {
+            if (name &&
+                initial &&
+                extensionFilter.includes(extension) &&
+                !hotUpdateAsset.test(file)) {
+                filteredFiles.push({ file, extension, name });
+            }
+        }
+        return filteredFiles;
+    }
+}
+exports.WriteIndexHtmlPlugin = WriteIndexHtmlPlugin;

package/src/utils/config.d.ts

@@ -0,0 +1,22 @@
+import { ExecutorContext } from '@nx/devkit';
+import { Configuration } from 'webpack';
+import { NormalizedWebpackExecutorOptions } from '../executors/webpack/schema';
+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 NxComposableWebpackPlugin {
+    (config: Configuration, ctx: NxWebpackExecutionContext): Configuration;
+}
+export interface AsyncNxComposableWebpackPlugin {
+    (config: Configuration, ctx: NxWebpackExecutionContext): Configuration | Promise<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

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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.isNxWebpackComposablePlugin = isNxWebpackComposablePlugin;
+function composePlugins(...plugins) {
+    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 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/create-copy-plugin.d.ts

@@ -0,0 +1,3 @@
+import * as CopyWebpackPlugin from 'copy-webpack-plugin';
+import { AssetGlobPattern } from '../executors/webpack/schema';
+export declare function createCopyPlugin(assets: AssetGlobPattern[]): CopyWebpackPlugin;

package/src/utils/create-copy-plugin.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCopyPlugin = void 0;
+const CopyWebpackPlugin = require("copy-webpack-plugin");
+function createCopyPlugin(assets) {
+    return new CopyWebpackPlugin({
+        patterns: assets.map((asset) => {
+            return {
+                context: asset.input,
+                // Now we remove starting slash to make Webpack place it from the output root.
+                to: asset.output,
+                from: asset.glob,
+                globOptions: {
+                    ignore: [
+                        '.gitkeep',
+                        '**/.DS_Store',
+                        '**/Thumbs.db',
+                        ...(asset.ignore ?? []),
+                    ],
+                    dot: true,
+                },
+            };
+        }),
+    });
+}
+exports.createCopyPlugin = createCopyPlugin;

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;