@nx/webpack 16.9.0-beta.0 → 16.9.0-beta.1

package/index.d.ts

@@ -13,3 +13,4 @@ export * from './src/executors/webpack/webpack.impl';
 export * from './src/utils/get-css-module-local-ident';
 export * from './src/utils/with-nx';
 export * from './src/utils/with-web';
+export * from './src/utils/module-federation/public-api';

package/index.js

@@ -16,3 +16,4 @@ tslib_1.__exportStar(require("./src/executors/webpack/webpack.impl"), exports);
 tslib_1.__exportStar(require("./src/utils/get-css-module-local-ident"), exports);
 tslib_1.__exportStar(require("./src/utils/with-nx"), exports);
 tslib_1.__exportStar(require("./src/utils/with-web"), exports);
+tslib_1.__exportStar(require("./src/utils/module-federation/public-api"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/webpack",
-  "version": "16.9.0-beta.0",
+  "version": "16.9.0-beta.1",
   "private": false,
   "description": "The Nx Plugin for Webpack contains executors and generators that support building applications using Webpack.",
   "repository": {
@@ -30,9 +30,9 @@
   },
   "dependencies": {
     "@babel/core": "^7.22.9",
-    "@nrwl/webpack": "16.9.0-beta.0",
-    "@nx/devkit": "16.9.0-beta.0",
-    "@nx/js": "16.9.0-beta.0",
+    "@nrwl/webpack": "16.9.0-beta.1",
+    "@nx/devkit": "16.9.0-beta.1",
+    "@nx/js": "16.9.0-beta.1",
     "autoprefixer": "^10.4.9",
     "babel-loader": "^9.1.2",
     "browserslist": "^4.21.4",
@@ -70,5 +70,5 @@
     "access": "public"
   },
   "type": "commonjs",
-  "gitHead": "822fb12c3f0bbaeb6d4a6fbc6cb1064a291e907f"
+  "gitHead": "5056d6cefb2949ba865019e8b71e633fba28c091"
 }

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

@@ -0,0 +1,6 @@
+import type { ProjectGraph } from '@nx/devkit';
+import type { WorkspaceLibrary } from './models';
+export declare function getDependentPackagesForProject(projectGraph: ProjectGraph, name: string): {
+    workspaceLibraries: WorkspaceLibrary[];
+    npmPackages: string[];
+};

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDependentPackagesForProject = void 0;
+const typescript_1 = require("./typescript");
+function getDependentPackagesForProject(projectGraph, name) {
+    const { npmPackages, workspaceLibraries } = collectDependencies(projectGraph, name);
+    return {
+        workspaceLibraries: [...workspaceLibraries.values()],
+        npmPackages: [...npmPackages],
+    };
+}
+exports.getDependentPackagesForProject = getDependentPackagesForProject;
+function collectDependencies(projectGraph, name, dependencies = {
+    workspaceLibraries: new Map(),
+    npmPackages: new Set(),
+}, seen = new Set()) {
+    if (seen.has(name)) {
+        return dependencies;
+    }
+    seen.add(name);
+    (projectGraph.dependencies[name] ?? []).forEach((dependency) => {
+        if (dependency.target.startsWith('npm:')) {
+            dependencies.npmPackages.add(dependency.target.replace('npm:', ''));
+        }
+        else {
+            dependencies.workspaceLibraries.set(dependency.target, {
+                name: dependency.target,
+                root: projectGraph.nodes[dependency.target].data.root,
+                importKey: getLibraryImportPath(dependency.target, projectGraph),
+            });
+            collectDependencies(projectGraph, dependency.target, dependencies, seen);
+        }
+    });
+    return dependencies;
+}
+function getLibraryImportPath(library, projectGraph) {
+    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;
+        }
+    }
+    return undefined;
+}

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

@@ -0,0 +1,5 @@
+export * from './share';
+export * from './dependencies';
+export * from './package-json';
+export * from './remotes';
+export * from './models';

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./share"), exports);
+tslib_1.__exportStar(require("./dependencies"), exports);
+tslib_1.__exportStar(require("./package-json"), exports);
+tslib_1.__exportStar(require("./remotes"), exports);
+tslib_1.__exportStar(require("./models"), exports);

package/src/utils/module-federation/models/index.d.ts

@@ -0,0 +1,39 @@
+import type { NormalModuleReplacementPlugin } from 'webpack';
+export type ModuleFederationLibrary = {
+    type: string;
+    name: string;
+};
+export type WorkspaceLibrary = {
+    name: string;
+    root: string;
+    importKey: string | undefined;
+};
+export type SharedWorkspaceLibraryConfig = {
+    getAliases: () => Record<string, string>;
+    getLibraries: (eager?: boolean) => Record<string, SharedLibraryConfig>;
+    getReplacementPlugin: () => NormalModuleReplacementPlugin;
+};
+export type Remotes = string[] | [remoteName: string, remoteUrl: string][];
+export interface SharedLibraryConfig {
+    singleton?: boolean;
+    strictVersion?: boolean;
+    requiredVersion?: false | string;
+    eager?: boolean;
+}
+export type SharedFunction = (libraryName: string, sharedConfig: SharedLibraryConfig) => undefined | false | SharedLibraryConfig;
+export type AdditionalSharedConfig = Array<string | [libraryName: string, sharedConfig: SharedLibraryConfig] | {
+    libraryName: string;
+    sharedConfig: SharedLibraryConfig;
+}>;
+export interface ModuleFederationConfig {
+    name: string;
+    remotes?: Remotes;
+    library?: ModuleFederationLibrary;
+    exposes?: Record<string, string>;
+    shared?: SharedFunction;
+    additionalShared?: AdditionalSharedConfig;
+}
+export type WorkspaceLibrarySecondaryEntryPoint = {
+    name: string;
+    path: string;
+};

package/src/utils/module-federation/models/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,8 @@
+export declare function readRootPackageJson(): {
+    dependencies?: {
+        [key: string]: string;
+    };
+    devDependencies?: {
+        [key: string]: string;
+    };
+};

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readRootPackageJson = void 0;
+const fs_1 = require("fs");
+const devkit_1 = require("@nx/devkit");
+function readRootPackageJson() {
+    const pkgJsonPath = (0, devkit_1.joinPathFragments)(devkit_1.workspaceRoot, 'package.json');
+    if (!(0, fs_1.existsSync)(pkgJsonPath)) {
+        throw new Error('NX MF: Could not find root package.json to determine dependency versions.');
+    }
+    return (0, devkit_1.readJsonFile)(pkgJsonPath);
+}
+exports.readRootPackageJson = readRootPackageJson;

package/src/utils/module-federation/public-api.d.ts

@@ -0,0 +1,6 @@
+import { AdditionalSharedConfig, ModuleFederationConfig, ModuleFederationLibrary, Remotes, SharedFunction, SharedLibraryConfig, SharedWorkspaceLibraryConfig, WorkspaceLibrary, WorkspaceLibrarySecondaryEntryPoint } from './models';
+import { applyAdditionalShared, applySharedFunction, getNpmPackageSharedConfig, sharePackages, shareWorkspaceLibraries } from './share';
+import { mapRemotes, mapRemotesForSSR } from './remotes';
+import { getDependentPackagesForProject } from './dependencies';
+import { readRootPackageJson } from './package-json';
+export { ModuleFederationConfig, SharedLibraryConfig, SharedWorkspaceLibraryConfig, AdditionalSharedConfig, WorkspaceLibrary, SharedFunction, WorkspaceLibrarySecondaryEntryPoint, Remotes, ModuleFederationLibrary, applySharedFunction, applyAdditionalShared, getNpmPackageSharedConfig, shareWorkspaceLibraries, sharePackages, mapRemotes, mapRemotesForSSR, getDependentPackagesForProject, readRootPackageJson, };

package/src/utils/module-federation/public-api.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readRootPackageJson = exports.getDependentPackagesForProject = exports.mapRemotesForSSR = exports.mapRemotes = exports.sharePackages = exports.shareWorkspaceLibraries = exports.getNpmPackageSharedConfig = exports.applyAdditionalShared = exports.applySharedFunction = void 0;
+const share_1 = require("./share");
+Object.defineProperty(exports, "applyAdditionalShared", { enumerable: true, get: function () { return share_1.applyAdditionalShared; } });
+Object.defineProperty(exports, "applySharedFunction", { enumerable: true, get: function () { return share_1.applySharedFunction; } });
+Object.defineProperty(exports, "getNpmPackageSharedConfig", { enumerable: true, get: function () { return share_1.getNpmPackageSharedConfig; } });
+Object.defineProperty(exports, "sharePackages", { enumerable: true, get: function () { return share_1.sharePackages; } });
+Object.defineProperty(exports, "shareWorkspaceLibraries", { enumerable: true, get: function () { return share_1.shareWorkspaceLibraries; } });
+const remotes_1 = require("./remotes");
+Object.defineProperty(exports, "mapRemotes", { enumerable: true, get: function () { return remotes_1.mapRemotes; } });
+Object.defineProperty(exports, "mapRemotesForSSR", { enumerable: true, get: function () { return remotes_1.mapRemotesForSSR; } });
+const dependencies_1 = require("./dependencies");
+Object.defineProperty(exports, "getDependentPackagesForProject", { enumerable: true, get: function () { return dependencies_1.getDependentPackagesForProject; } });
+const package_json_1 = require("./package-json");
+Object.defineProperty(exports, "readRootPackageJson", { enumerable: true, get: function () { return package_json_1.readRootPackageJson; } });

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

@@ -0,0 +1,19 @@
+import { Remotes } from './models';
+/**
+ * Map remote names to a format that can be understood and used by Module
+ * Federation.
+ *
+ * @param remotes - The remotes to map
+ * @param remoteEntryExt - The file extension of the remoteEntry file
+ * @param determineRemoteUrl - The function used to lookup the URL of the served remote
+ */
+export declare function mapRemotes(remotes: Remotes, remoteEntryExt: 'js' | 'mjs', determineRemoteUrl: (remote: string) => string): Record<string, string>;
+/**
+ * Map remote names to a format that can be understood and used by Module
+ * Federation.
+ *
+ * @param remotes - The remotes to map
+ * @param remoteEntryExt - The file extension of the remoteEntry file
+ * @param determineRemoteUrl - The function used to lookup the URL of the served remote
+ */
+export declare function mapRemotesForSSR(remotes: Remotes, remoteEntryExt: 'js' | 'mjs', determineRemoteUrl: (remote: string) => string): Record<string, string>;

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

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapRemotesForSSR = exports.mapRemotes = void 0;
+const path_1 = require("path");
+/**
+ * Map remote names to a format that can be understood and used by Module
+ * Federation.
+ *
+ * @param remotes - The remotes to map
+ * @param remoteEntryExt - The file extension of the remoteEntry file
+ * @param determineRemoteUrl - The function used to lookup the URL of the served remote
+ */
+function mapRemotes(remotes, remoteEntryExt, determineRemoteUrl) {
+    const mappedRemotes = {};
+    for (const remote of remotes) {
+        if (Array.isArray(remote)) {
+            const [remoteName, remoteLocation] = remote;
+            const remoteLocationExt = (0, path_1.extname)(remoteLocation);
+            mappedRemotes[remoteName] = ['.js', '.mjs'].includes(remoteLocationExt)
+                ? remoteLocation
+                : `${remoteLocation.endsWith('/')
+                    ? remoteLocation.slice(0, -1)
+                    : remoteLocation}/remoteEntry.${remoteEntryExt}`;
+        }
+        else if (typeof remote === 'string') {
+            mappedRemotes[remote] = determineRemoteUrl(remote);
+        }
+    }
+    return mappedRemotes;
+}
+exports.mapRemotes = mapRemotes;
+/**
+ * Map remote names to a format that can be understood and used by Module
+ * Federation.
+ *
+ * @param remotes - The remotes to map
+ * @param remoteEntryExt - The file extension of the remoteEntry file
+ * @param determineRemoteUrl - The function used to lookup the URL of the served remote
+ */
+function mapRemotesForSSR(remotes, remoteEntryExt, determineRemoteUrl) {
+    const mappedRemotes = {};
+    for (const remote of remotes) {
+        if (Array.isArray(remote)) {
+            const [remoteName, remoteLocation] = remote;
+            const remoteLocationExt = (0, path_1.extname)(remoteLocation);
+            mappedRemotes[remoteName] = `${remoteName}@${['.js', '.mjs'].includes(remoteLocationExt)
+                ? remoteLocation
+                : `${remoteLocation.endsWith('/')
+                    ? remoteLocation.slice(0, -1)
+                    : remoteLocation}/remoteEntry.${remoteEntryExt}`}`;
+        }
+        else if (typeof remote === 'string') {
+            mappedRemotes[remote] = `${remote}@${determineRemoteUrl(remote)}`;
+        }
+    }
+    return mappedRemotes;
+}
+exports.mapRemotesForSSR = mapRemotesForSSR;

package/src/utils/module-federation/secondary-entry-points.d.ts

@@ -0,0 +1,12 @@
+import type { WorkspaceLibrary } from './models';
+import { WorkspaceLibrarySecondaryEntryPoint } from './models';
+export declare function collectWorkspaceLibrarySecondaryEntryPoints(library: WorkspaceLibrary, tsconfigPathAliases: Record<string, string[]>): WorkspaceLibrarySecondaryEntryPoint[];
+export declare function getNonNodeModulesSubDirs(directory: string): string[];
+export declare function recursivelyCollectSecondaryEntryPointsFromDirectory(pkgName: string, pkgVersion: string, pkgRoot: string, mainEntryPointExports: any | undefined, directories: string[], collectedPackages: {
+    name: string;
+    version: string;
+}[]): void;
+export declare function collectPackageSecondaryEntryPoints(pkgName: string, pkgVersion: string, collectedPackages: {
+    name: string;
+    version: string;
+}[]): void;

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 18 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 libraries - 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(libraries: 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,183 @@
+"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");
+/**
+ * Build an object of functions to be used with the ModuleFederationPlugin to
+ * share Nx Workspace Libraries between Hosts and Remotes.
+ *
+ * @param libraries - The Nx Workspace Libraries to share
+ * @param tsConfigPath - The path to TS Config File that contains the Path Mappings for the Libraries
+ */
+function shareWorkspaceLibraries(libraries, tsConfigPath = process.env.NX_TSCONFIG_PATH ?? (0, typescript_1.getRootTsConfigPath)()) {
+    if (!libraries) {
+        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 = libraries.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: (eager) => pathMappings.reduce((libraries, library) => ({
+            ...libraries,
+            [library.name]: { 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,49 @@
+"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;
+let tsPathMappings;
+function readTsPathMappings(tsConfigPath = process.env.NX_TSCONFIG_PATH ?? getRootTsConfigPath()) {
+    if (tsPathMappings) {
+        return tsPathMappings;
+    }
+    tsConfig ??= readTsConfiguration(tsConfigPath);
+    tsPathMappings = {};
+    Object.entries(tsConfig.options?.paths ?? {}).forEach(([alias, paths]) => {
+        tsPathMappings[alias] = paths.map((path) => path.replace(/^\.\//, ''));
+    });
+    return tsPathMappings;
+}
+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;
+}