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

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

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectPackageSecondaryEntryPoints = exports.recursivelyCollectSecondaryEntryPointsFromDirectory = exports.getNonNodeModulesSubDirs = exports.collectWorkspaceLibrarySecondaryEntryPoints = void 0;
+const path_1 = require("path");
+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 19 when Nx 16.7.0 is no longer supported
+readModulePackageJson =
+    readModulePackageJson ??
+        require('nx/src/utils/package-json').readModulePackageJson;
+function collectWorkspaceLibrarySecondaryEntryPoints(library, tsconfigPathAliases) {
+    const libraryRoot = (0, path_1.join)(devkit_1.workspaceRoot, library.root);
+    const needsSecondaryEntryPointsCollected = (0, fs_1.existsSync)((0, path_1.join)(libraryRoot, 'ng-package.json'));
+    const secondaryEntryPoints = [];
+    if (needsSecondaryEntryPointsCollected) {
+        const tsConfigAliasesForLibWithSecondaryEntryPoints = Object.entries(tsconfigPathAliases).reduce((acc, [tsKey, tsPaths]) => {
+            if (!tsKey.startsWith(library.importKey)) {
+                return { ...acc };
+            }
+            if (tsPaths.some((path) => path.startsWith(`${library.root}/`))) {
+                acc = { ...acc, [tsKey]: tsPaths };
+            }
+            return acc;
+        }, {});
+        for (const [alias] of Object.entries(tsConfigAliasesForLibWithSecondaryEntryPoints)) {
+            const pathToLib = (0, path_1.dirname)((0, path_1.join)(devkit_1.workspaceRoot, tsconfigPathAliases[alias][0]));
+            let searchDir = pathToLib;
+            while (searchDir !== libraryRoot) {
+                if ((0, fs_1.existsSync)((0, path_1.join)(searchDir, 'ng-package.json'))) {
+                    secondaryEntryPoints.push({ name: alias, path: pathToLib });
+                    break;
+                }
+                searchDir = (0, path_1.dirname)(searchDir);
+            }
+        }
+    }
+    return secondaryEntryPoints;
+}
+exports.collectWorkspaceLibrarySecondaryEntryPoints = collectWorkspaceLibrarySecondaryEntryPoints;
+function getNonNodeModulesSubDirs(directory) {
+    return (0, fs_1.readdirSync)(directory)
+        .filter((file) => file !== 'node_modules')
+        .map((file) => (0, path_1.join)(directory, file))
+        .filter((file) => (0, fs_1.lstatSync)(file).isDirectory());
+}
+exports.getNonNodeModulesSubDirs = getNonNodeModulesSubDirs;
+function recursivelyCollectSecondaryEntryPointsFromDirectory(pkgName, pkgVersion, pkgRoot, mainEntryPointExports, directories, collectedPackages) {
+    for (const directory of directories) {
+        const packageJsonPath = (0, path_1.join)(directory, 'package.json');
+        const relativeEntryPointPath = (0, path_1.relative)(pkgRoot, directory);
+        const entryPointName = (0, devkit_1.joinPathFragments)(pkgName, relativeEntryPointPath);
+        if ((0, fs_1.existsSync)(packageJsonPath)) {
+            try {
+                // require the secondary entry point to try to rule out sample code
+                require.resolve(entryPointName, { paths: [devkit_1.workspaceRoot] });
+                const { name } = (0, devkit_1.readJsonFile)(packageJsonPath);
+                // further check to make sure what we were able to require is the
+                // same as the package name
+                if (name === entryPointName) {
+                    collectedPackages.push({ name, version: pkgVersion });
+                }
+            }
+            catch { }
+        }
+        else if (mainEntryPointExports) {
+            // if the package.json doesn't exist, check if the directory is
+            // exported by the main entry point
+            const entryPointExportKey = `./${relativeEntryPointPath}`;
+            const entryPointInfo = mainEntryPointExports[entryPointExportKey];
+            if (entryPointInfo) {
+                collectedPackages.push({
+                    name: entryPointName,
+                    version: pkgVersion,
+                });
+            }
+        }
+        const subDirs = getNonNodeModulesSubDirs(directory);
+        recursivelyCollectSecondaryEntryPointsFromDirectory(pkgName, pkgVersion, pkgRoot, mainEntryPointExports, subDirs, collectedPackages);
+    }
+}
+exports.recursivelyCollectSecondaryEntryPointsFromDirectory = recursivelyCollectSecondaryEntryPointsFromDirectory;
+function collectPackageSecondaryEntryPoints(pkgName, pkgVersion, collectedPackages) {
+    let pathToPackage;
+    let packageJsonPath;
+    let packageJson;
+    try {
+        ({ path: packageJsonPath, packageJson } = readModulePackageJson(pkgName));
+        pathToPackage = (0, path_1.dirname)(packageJsonPath);
+    }
+    catch {
+        // the package.json might not resolve if the package has the "exports"
+        // entry and is not exporting the package.json file, fall back to trying
+        // to find it from the top-level node_modules
+        pathToPackage = (0, path_1.join)(devkit_1.workspaceRoot, 'node_modules', pkgName);
+        packageJsonPath = (0, path_1.join)(pathToPackage, 'package.json');
+        if (!(0, fs_1.existsSync)(packageJsonPath)) {
+            // might not exist if it's nested in another package, just return here
+            return;
+        }
+        packageJson = (0, devkit_1.readJsonFile)(packageJsonPath);
+    }
+    const { exports } = packageJson;
+    const subDirs = getNonNodeModulesSubDirs(pathToPackage);
+    recursivelyCollectSecondaryEntryPointsFromDirectory(pkgName, pkgVersion, pathToPackage, exports, subDirs, collectedPackages);
+}
+exports.collectPackageSecondaryEntryPoints = collectPackageSecondaryEntryPoints;

package/src/utils/module-federation/share.d.ts

@@ -0,0 +1,48 @@
+import type { SharedLibraryConfig, SharedWorkspaceLibraryConfig, WorkspaceLibrary } from './models';
+import { AdditionalSharedConfig, SharedFunction } from './models';
+import { type ProjectGraph } from '@nx/devkit';
+/**
+ * Build an object of functions to be used with the ModuleFederationPlugin to
+ * share Nx Workspace Libraries between Hosts and Remotes.
+ *
+ * @param workspaceLibs - The Nx Workspace Libraries to share
+ * @param tsConfigPath - The path to TS Config File that contains the Path Mappings for the Libraries
+ */
+export declare function shareWorkspaceLibraries(workspaceLibs: WorkspaceLibrary[], tsConfigPath?: string): SharedWorkspaceLibraryConfig;
+/**
+ * Build the Module Federation Share Config for a specific package and the
+ * specified version of that package.
+ * @param pkgName - Name of the package to share
+ * @param version - Version of the package to require by other apps in the Module Federation setup
+ */
+export declare function getNpmPackageSharedConfig(pkgName: string, version: string): SharedLibraryConfig | undefined;
+/**
+ * Create a dictionary of packages and their Module Federation Shared Config
+ * from an array of package names.
+ *
+ * Lookup the versions of the packages from the root package.json file in the
+ * workspace.
+ * @param packages - Array of package names as strings
+ */
+export declare function sharePackages(packages: string[]): Record<string, SharedLibraryConfig>;
+/**
+ * Apply a custom function provided by the user that will modify the Shared Config
+ * of the dependencies for the Module Federation build.
+ *
+ * @param sharedConfig - The original Shared Config to be modified
+ * @param sharedFn - The custom function to run
+ */
+export declare function applySharedFunction(sharedConfig: Record<string, SharedLibraryConfig>, sharedFn: SharedFunction | undefined): void;
+/**
+ * Add additional dependencies to the shared package that may not have been
+ * discovered by the project graph.
+ *
+ * This can be useful for applications that use a Dependency Injection system
+ * that expects certain Singleton values to be present in the shared injection
+ * hierarchy.
+ *
+ * @param sharedConfig - The original Shared Config
+ * @param additionalShared - The additional dependencies to add
+ * @param projectGraph - The Nx project graph
+ */
+export declare function applyAdditionalShared(sharedConfig: Record<string, SharedLibraryConfig>, additionalShared: AdditionalSharedConfig | undefined, projectGraph: ProjectGraph): void;

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

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyAdditionalShared = exports.applySharedFunction = exports.sharePackages = exports.getNpmPackageSharedConfig = exports.shareWorkspaceLibraries = void 0;
+const path_1 = require("path");
+const package_json_1 = require("./package-json");
+const typescript_1 = require("./typescript");
+const secondary_entry_points_1 = require("./secondary-entry-points");
+const devkit_1 = require("@nx/devkit");
+const fs_1 = require("fs");
+/**
+ * Build an object of functions to be used with the ModuleFederationPlugin to
+ * share Nx Workspace Libraries between Hosts and Remotes.
+ *
+ * @param workspaceLibs - The Nx Workspace Libraries to share
+ * @param tsConfigPath - The path to TS Config File that contains the Path Mappings for the Libraries
+ */
+function shareWorkspaceLibraries(workspaceLibs, tsConfigPath = process.env.NX_TSCONFIG_PATH ?? (0, typescript_1.getRootTsConfigPath)()) {
+    if (!workspaceLibs) {
+        return getEmptySharedLibrariesConfig();
+    }
+    const tsconfigPathAliases = (0, typescript_1.readTsPathMappings)(tsConfigPath);
+    if (!Object.keys(tsconfigPathAliases).length) {
+        return getEmptySharedLibrariesConfig();
+    }
+    const pathMappings = [];
+    for (const [key, paths] of Object.entries(tsconfigPathAliases)) {
+        const library = workspaceLibs.find((lib) => lib.importKey === key);
+        if (!library) {
+            continue;
+        }
+        // This is for Angular Projects that use ng-package.json
+        // It will do nothing for React Projects
+        (0, secondary_entry_points_1.collectWorkspaceLibrarySecondaryEntryPoints)(library, tsconfigPathAliases).forEach(({ name, path }) => pathMappings.push({
+            name,
+            path,
+        }));
+        pathMappings.push({
+            name: key,
+            path: (0, path_1.normalize)((0, path_1.join)(devkit_1.workspaceRoot, paths[0])),
+        });
+    }
+    const webpack = require('webpack');
+    return {
+        getAliases: () => pathMappings.reduce((aliases, library) => ({ ...aliases, [library.name]: library.path }), {}),
+        getLibraries: (projectRoot, eager) => {
+            let pkgJson = null;
+            if (projectRoot &&
+                (0, fs_1.existsSync)((0, devkit_1.joinPathFragments)(devkit_1.workspaceRoot, projectRoot, 'package.json'))) {
+                pkgJson = (0, devkit_1.readJsonFile)((0, devkit_1.joinPathFragments)(devkit_1.workspaceRoot, projectRoot, 'package.json'));
+            }
+            return pathMappings.reduce((libraries, library) => {
+                // Check to see if the library version is declared in the app's package.json
+                let version = pkgJson?.dependencies?.[library.name];
+                if (!version && workspaceLibs.length > 0) {
+                    const workspaceLib = workspaceLibs.find((lib) => lib.importKey === library.name);
+                    const libPackageJsonPath = workspaceLib
+                        ? (0, path_1.join)(workspaceLib.root, 'package.json')
+                        : null;
+                    if (libPackageJsonPath && (0, fs_1.existsSync)(libPackageJsonPath)) {
+                        pkgJson = (0, devkit_1.readJsonFile)(libPackageJsonPath);
+                        if (pkgJson) {
+                            version = pkgJson.version;
+                        }
+                    }
+                }
+                return {
+                    ...libraries,
+                    [library.name]: {
+                        ...(version
+                            ? {
+                                requiredVersion: version,
+                                singleton: true,
+                            }
+                            : { requiredVersion: false }),
+                        eager,
+                    },
+                };
+            }, {});
+        },
+        getReplacementPlugin: () => new webpack.NormalModuleReplacementPlugin(/./, (req) => {
+            if (!req.request.startsWith('.')) {
+                return;
+            }
+            const from = req.context;
+            const to = (0, path_1.normalize)((0, path_1.join)(req.context, req.request));
+            for (const library of pathMappings) {
+                const libFolder = (0, path_1.normalize)((0, path_1.dirname)(library.path));
+                if (!from.startsWith(libFolder) && to.startsWith(libFolder)) {
+                    req.request = library.name;
+                }
+            }
+        }),
+    };
+}
+exports.shareWorkspaceLibraries = shareWorkspaceLibraries;
+/**
+ * Build the Module Federation Share Config for a specific package and the
+ * specified version of that package.
+ * @param pkgName - Name of the package to share
+ * @param version - Version of the package to require by other apps in the Module Federation setup
+ */
+function getNpmPackageSharedConfig(pkgName, version) {
+    if (!version) {
+        devkit_1.logger.warn(`Could not find a version for "${pkgName}" in the root "package.json" ` +
+            'when collecting shared packages for the Module Federation setup. ' +
+            'The package will not be shared.');
+        return undefined;
+    }
+    return { singleton: true, strictVersion: true, requiredVersion: version };
+}
+exports.getNpmPackageSharedConfig = getNpmPackageSharedConfig;
+/**
+ * Create a dictionary of packages and their Module Federation Shared Config
+ * from an array of package names.
+ *
+ * Lookup the versions of the packages from the root package.json file in the
+ * workspace.
+ * @param packages - Array of package names as strings
+ */
+function sharePackages(packages) {
+    const pkgJson = (0, package_json_1.readRootPackageJson)();
+    const allPackages = [];
+    packages.forEach((pkg) => {
+        const pkgVersion = pkgJson.dependencies?.[pkg] ?? pkgJson.devDependencies?.[pkg];
+        allPackages.push({ name: pkg, version: pkgVersion });
+        (0, secondary_entry_points_1.collectPackageSecondaryEntryPoints)(pkg, pkgVersion, allPackages);
+    });
+    return allPackages.reduce((shared, pkg) => {
+        const config = getNpmPackageSharedConfig(pkg.name, pkg.version);
+        if (config) {
+            shared[pkg.name] = config;
+        }
+        return shared;
+    }, {});
+}
+exports.sharePackages = sharePackages;
+/**
+ * Apply a custom function provided by the user that will modify the Shared Config
+ * of the dependencies for the Module Federation build.
+ *
+ * @param sharedConfig - The original Shared Config to be modified
+ * @param sharedFn - The custom function to run
+ */
+function applySharedFunction(sharedConfig, sharedFn) {
+    if (!sharedFn) {
+        return;
+    }
+    for (const [libraryName, library] of Object.entries(sharedConfig)) {
+        const mappedDependency = sharedFn(libraryName, library);
+        if (mappedDependency === false) {
+            delete sharedConfig[libraryName];
+            continue;
+        }
+        else if (!mappedDependency) {
+            continue;
+        }
+        sharedConfig[libraryName] = mappedDependency;
+    }
+}
+exports.applySharedFunction = applySharedFunction;
+/**
+ * Add additional dependencies to the shared package that may not have been
+ * discovered by the project graph.
+ *
+ * This can be useful for applications that use a Dependency Injection system
+ * that expects certain Singleton values to be present in the shared injection
+ * hierarchy.
+ *
+ * @param sharedConfig - The original Shared Config
+ * @param additionalShared - The additional dependencies to add
+ * @param projectGraph - The Nx project graph
+ */
+function applyAdditionalShared(sharedConfig, additionalShared, projectGraph) {
+    if (!additionalShared) {
+        return;
+    }
+    for (const shared of additionalShared) {
+        if (typeof shared === 'string') {
+            addStringDependencyToSharedConfig(sharedConfig, shared, projectGraph);
+        }
+        else if (Array.isArray(shared)) {
+            sharedConfig[shared[0]] = shared[1];
+        }
+        else if (typeof shared === 'object') {
+            sharedConfig[shared.libraryName] = shared.sharedConfig;
+        }
+    }
+}
+exports.applyAdditionalShared = applyAdditionalShared;
+function addStringDependencyToSharedConfig(sharedConfig, dependency, projectGraph) {
+    if (projectGraph.nodes[dependency]) {
+        sharedConfig[dependency] = { requiredVersion: false };
+    }
+    else if (projectGraph.externalNodes?.[`npm:${dependency}`]) {
+        const pkgJson = (0, package_json_1.readRootPackageJson)();
+        const config = getNpmPackageSharedConfig(dependency, pkgJson.dependencies?.[dependency] ??
+            pkgJson.devDependencies?.[dependency]);
+        if (!config) {
+            return;
+        }
+        sharedConfig[dependency] = config;
+    }
+    else {
+        throw new Error(`The specified dependency "${dependency}" in the additionalShared configuration does not exist in the project graph. ` +
+            `Please check your additionalShared configuration and make sure you are including valid workspace projects or npm packages.`);
+    }
+}
+function getEmptySharedLibrariesConfig() {
+    const webpack = require('webpack');
+    return {
+        getAliases: () => ({}),
+        getLibraries: () => ({}),
+        getReplacementPlugin: () => new webpack.NormalModuleReplacementPlugin(/./, () => { }),
+    };
+}

package/src/utils/module-federation/typescript.d.ts

@@ -0,0 +1,4 @@
+import { ParsedCommandLine } from 'typescript';
+export declare function readTsPathMappings(tsConfigPath?: string): ParsedCommandLine['options']['paths'];
+export declare function readTsConfig(tsConfigPath: string): ParsedCommandLine;
+export declare function getRootTsConfigPath(): string | null;

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRootTsConfigPath = exports.readTsConfig = exports.readTsPathMappings = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const devkit_1 = require("@nx/devkit");
+let tsConfig = new Map();
+let tsPathMappings = new Map();
+function readTsPathMappings(tsConfigPath = process.env.NX_TSCONFIG_PATH ?? getRootTsConfigPath()) {
+    if (tsPathMappings.has(tsConfigPath)) {
+        return tsPathMappings.get(tsConfigPath);
+    }
+    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.get(tsConfigPath);
+}
+exports.readTsPathMappings = readTsPathMappings;
+function readTsConfiguration(tsConfigPath) {
+    if (!(0, fs_1.existsSync)(tsConfigPath)) {
+        throw new Error(`NX MF: TsConfig Path for workspace libraries does not exist! (${tsConfigPath}).`);
+    }
+    return readTsConfig(tsConfigPath);
+}
+let tsModule;
+function readTsConfig(tsConfigPath) {
+    if (!tsModule) {
+        tsModule = require('typescript');
+    }
+    const readResult = tsModule.readConfigFile(tsConfigPath, tsModule.sys.readFile);
+    return tsModule.parseJsonConfigFileContent(readResult.config, tsModule.sys, (0, path_1.dirname)(tsConfigPath));
+}
+exports.readTsConfig = readTsConfig;
+function getRootTsConfigPath() {
+    const tsConfigFileName = getRootTsConfigFileName();
+    return tsConfigFileName ? (0, path_1.join)(devkit_1.workspaceRoot, tsConfigFileName) : null;
+}
+exports.getRootTsConfigPath = getRootTsConfigPath;
+function getRootTsConfigFileName() {
+    for (const tsConfigName of ['tsconfig.base.json', 'tsconfig.json']) {
+        const tsConfigPath = (0, path_1.join)(devkit_1.workspaceRoot, tsConfigName);
+        if ((0, fs_1.existsSync)(tsConfigPath)) {
+            return tsConfigName;
+        }
+    }
+    return null;
+}

package/src/utils/run-webpack.d.ts

@@ -0,0 +1,5 @@
+import { Observable } from 'rxjs';
+export declare function runWebpackDevServer(config: any, webpack: typeof import('webpack'), WebpackDevServer: typeof import('webpack-dev-server')): Observable<{
+    stats: any;
+    baseUrl: string;
+}>;

package/src/utils/run-webpack.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runWebpackDevServer = void 0;
+const rxjs_1 = require("rxjs");
+function runWebpackDevServer(config, webpack, WebpackDevServer) {
+    return new rxjs_1.Observable((subscriber) => {
+        const webpackCompiler = webpack(config);
+        let baseUrl;
+        webpackCompiler.hooks.done.tap('build-webpack', (stats) => {
+            subscriber.next({ stats, baseUrl });
+        });
+        const devServerConfig = config.devServer || {};
+        const originalOnListen = devServerConfig.onListening;
+        devServerConfig.onListening = function (server) {
+            if (typeof originalOnListen === 'function') {
+                originalOnListen(server);
+            }
+            const devServerOptions = server.options;
+            baseUrl = `${server.options.https ? 'https' : 'http'}://${server.options.host}:${server.options.port}${devServerOptions.devMiddleware.publicPath}`;
+        };
+        const webpackServer = new WebpackDevServer(devServerConfig, webpackCompiler);
+        try {
+            webpackServer.start().catch((err) => subscriber.error(err));
+            return () => webpackServer.stop();
+        }
+        catch (e) {
+            throw new Error('Could not start start dev server');
+        }
+    });
+}
+exports.runWebpackDevServer = runWebpackDevServer;

package/src/utils/versions.d.ts

@@ -0,0 +1,8 @@
+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";
+export declare const urlLoaderVersion = "^4.1.1";

package/src/utils/versions.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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';
+exports.reactRefreshVersion = '^0.10.0';
+exports.urlLoaderVersion = '^4.1.1';

package/src/utils/web-babel-loader.js

@@ -0,0 +1,17 @@
+module.exports = require('babel-loader').custom(() => {
+    return {
+        customOptions({ isTest, isModern, emitDecoratorMetadata, ...loader }) {
+            return {
+                custom: { isTest, isModern, emitDecoratorMetadata },
+                loader,
+            };
+        },
+        config(cfg, { customOptions: { isTest, isModern, emitDecoratorMetadata } }) {
+            // Add hint to our babel preset so it can handle modern vs legacy bundles.
+            cfg.options.caller.isModern = isModern;
+            cfg.options.caller.isTest = isTest;
+            cfg.options.caller.emitDecoratorMetadata = emitDecoratorMetadata;
+            return cfg.options;
+        },
+    };
+});

package/src/utils/webpack/deprecated-stylus-loader.d.ts

@@ -0,0 +1 @@
+export default function (source: string): string;

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+// @ts-ignore
+const stylusLoader = require("stylus-loader");
+// 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 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.d.ts

@@ -0,0 +1 @@
+export declare function interpolateEnvironmentVariablesToIndex(contents: string, deployUrl?: string): string;

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interpolateEnvironmentVariablesToIndex = void 0;
+function interpolateEnvironmentVariablesToIndex(contents, deployUrl) {
+    const environmentVariables = getClientEnvironment(deployUrl || '');
+    return interpolateEnvironmentVariables(contents, environmentVariables);
+}
+exports.interpolateEnvironmentVariablesToIndex = interpolateEnvironmentVariablesToIndex;
+const NX_PREFIX = /^NX_/i;
+function isNxEnvironmentKey(x) {
+    return NX_PREFIX.test(x);
+}
+function getClientEnvironment(deployUrl) {
+    return Object.keys(process.env)
+        .filter(isNxEnvironmentKey)
+        .reduce((env, key) => {
+        env[key] = process.env[key];
+        return env;
+    }, {
+        NODE_ENV: process.env.NODE_ENV || 'development',
+        DEPLOY_URL: deployUrl || process.env.DEPLOY_URL || '',
+    });
+}
+function interpolateEnvironmentVariables(documentContents, environmentVariables) {
+    let temp = documentContents;
+    for (const [key, value] of Object.entries(environmentVariables)) {
+        temp = temp.replace(new RegExp(`%${key}%`, 'g'), value);
+    }
+    return temp;
+}

package/src/utils/webpack/normalize-entry.d.ts

@@ -0,0 +1,2 @@
+import { ExtraEntryPoint, NormalizedEntryPoint } from '../models';
+export declare function normalizeExtraEntryPoints(extraEntryPoints: ExtraEntryPoint[], defaultBundleName: string): NormalizedEntryPoint[];

package/src/utils/webpack/normalize-entry.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeExtraEntryPoints = void 0;
+function normalizeExtraEntryPoints(extraEntryPoints, defaultBundleName) {
+    return extraEntryPoints.map((entry) => {
+        let normalizedEntry;
+        if (typeof entry === 'string') {
+            normalizedEntry = {
+                input: entry,
+                inject: true,
+                bundleName: defaultBundleName,
+            };
+        }
+        else {
+            const { inject = true, ...newEntry } = entry;
+            let bundleName;
+            if (entry.bundleName) {
+                bundleName = entry.bundleName;
+            }
+            else {
+                bundleName = defaultBundleName;
+            }
+            normalizedEntry = { ...newEntry, bundleName };
+        }
+        return normalizedEntry;
+    });
+}
+exports.normalizeExtraEntryPoints = normalizeExtraEntryPoints;

package/src/utils/webpack/package-chunk-sort.d.ts

@@ -0,0 +1,5 @@
+import { ExtraEntryPoint } from '../models';
+export declare function generateEntryPoints(appConfig: {
+    styles: ExtraEntryPoint[];
+    scripts: ExtraEntryPoint[];
+}): string[];

package/src/utils/webpack/package-chunk-sort.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEntryPoints = void 0;
+const normalize_entry_1 = require("./normalize-entry");
+function generateEntryPoints(appConfig) {
+    // Add all styles/scripts, except lazy-loaded ones.
+    const extraEntryPoints = (extraEntryPoints, defaultBundleName) => {
+        const entryPoints = (0, normalize_entry_1.normalizeExtraEntryPoints)(extraEntryPoints, defaultBundleName).map((entry) => entry.bundleName);
+        // remove duplicates
+        return [...new Set(entryPoints)];
+    };
+    const entryPoints = [
+        'runtime',
+        'polyfills',
+        'sw-register',
+        ...extraEntryPoints(appConfig.styles, 'styles'),
+        ...extraEntryPoints(appConfig.scripts, 'scripts'),
+        'vendor',
+        'main',
+    ];
+    const duplicates = [
+        ...new Set(entryPoints.filter((x) => entryPoints.indexOf(x) !== entryPoints.lastIndexOf(x))),
+    ];
+    if (duplicates.length > 0) {
+        throw new Error(`Multiple bundles have been named the same: '${duplicates.join(`', '`)}'.`);
+    }
+    return entryPoints;
+}
+exports.generateEntryPoints = generateEntryPoints;

package/src/utils/webpack/plugins/postcss-cli-resources.d.ts

@@ -0,0 +1,13 @@
+import { LoaderContext } from 'webpack';
+export interface PostcssCliResourcesOptions {
+    baseHref?: string;
+    deployUrl?: string;
+    resourcesOutputPath?: string;
+    rebaseRootRelative?: boolean;
+    filename: string;
+    loader: LoaderContext<unknown>;
+}
+export declare function PostcssCliResources(options: PostcssCliResourcesOptions): {
+    postcssPlugin: string;
+    Once(root: any): Promise<void[]>;
+};