@nx/module-federation 20.2.0-beta.2 → 20.2.0-beta.4

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

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectWorkspaceLibrarySecondaryEntryPoints = collectWorkspaceLibrarySecondaryEntryPoints;
+exports.getNonNodeModulesSubDirs = getNonNodeModulesSubDirs;
+exports.recursivelyCollectSecondaryEntryPointsFromDirectory = recursivelyCollectSecondaryEntryPointsFromDirectory;
+exports.collectPackageSecondaryEntryPoints = collectPackageSecondaryEntryPoints;
+const path_1 = require("path");
+const fs_1 = require("fs");
+const devkit_1 = require("@nx/devkit");
+const package_json_1 = require("nx/src/utils/package-json");
+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;
+}
+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());
+}
+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);
+    }
+}
+function collectPackagesFromExports(pkgName, pkgVersion, exports, collectedPackages) {
+    for (const [relativeEntryPoint, exportOptions] of Object.entries(exports)) {
+        const defaultExportOptions = typeof exportOptions?.['default'] === 'string'
+            ? exportOptions?.['default']
+            : exportOptions?.['default']?.['default'];
+        if (defaultExportOptions?.search(/\.(js|mjs|cjs)$/)) {
+            let entryPointName = (0, devkit_1.joinPathFragments)(pkgName, relativeEntryPoint);
+            if (entryPointName.endsWith('.json')) {
+                entryPointName = (0, path_1.dirname)(entryPointName);
+            }
+            if (entryPointName === '.') {
+                continue;
+            }
+            if (collectedPackages.find((p) => p.name === entryPointName)) {
+                continue;
+            }
+            collectedPackages.push({ name: entryPointName, version: pkgVersion });
+        }
+    }
+}
+function collectPackageSecondaryEntryPoints(pkgName, pkgVersion, collectedPackages) {
+    let pathToPackage;
+    let packageJsonPath;
+    let packageJson;
+    try {
+        ({ path: packageJsonPath, packageJson } = (0, package_json_1.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;
+    if (exports) {
+        collectPackagesFromExports(pkgName, pkgVersion, exports, collectedPackages);
+    }
+    const subDirs = getNonNodeModulesSubDirs(pathToPackage);
+    recursivelyCollectSecondaryEntryPointsFromDirectory(pkgName, pkgVersion, pathToPackage, exports, subDirs, collectedPackages);
+}

package/src/utils/share.d.ts

@@ -0,0 +1,49 @@
+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
+ * @param bundler - The bundler to use for the replacement plugin
+ */
+export declare function shareWorkspaceLibraries(workspaceLibs: WorkspaceLibrary[], tsConfigPath?: string, bundler?: 'rspack' | 'webpack'): 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/share.js

@@ -0,0 +1,246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shareWorkspaceLibraries = shareWorkspaceLibraries;
+exports.getNpmPackageSharedConfig = getNpmPackageSharedConfig;
+exports.sharePackages = sharePackages;
+exports.applySharedFunction = applySharedFunction;
+exports.applyAdditionalShared = applyAdditionalShared;
+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");
+const core_1 = require("@rspack/core");
+/**
+ * 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
+ * @param bundler - The bundler to use for the replacement plugin
+ */
+function shareWorkspaceLibraries(workspaceLibs, tsConfigPath = process.env.NX_TSCONFIG_PATH ?? (0, typescript_1.getRootTsConfigPath)(), bundler = 'rspack') {
+    if (!workspaceLibs) {
+        return getEmptySharedLibrariesConfig();
+    }
+    const tsconfigPathAliases = (0, typescript_1.readTsPathMappings)(tsConfigPath);
+    if (!Object.keys(tsconfigPathAliases).length) {
+        return getEmptySharedLibrariesConfig();
+    }
+    // Nested projects must come first, sort them as such
+    const sortedTsConfigPathAliases = {};
+    Object.keys(tsconfigPathAliases)
+        .sort((a, b) => {
+        return b.split('/').length - a.split('/').length;
+    })
+        .forEach((key) => (sortedTsConfigPathAliases[key] = tsconfigPathAliases[key]));
+    const pathMappings = [];
+    for (const [key, paths] of Object.entries(sortedTsConfigPathAliases)) {
+        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, sortedTsConfigPathAliases).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 normalModuleReplacementPluginImpl = bundler === 'rspack'
+        ? core_1.NormalModuleReplacementPlugin
+        : require('webpack').NormalModuleReplacementPlugin;
+    return {
+        getAliases: () => pathMappings.reduce((aliases, library) => ({
+            ...aliases,
+            // If the library path ends in a wildcard, remove it as webpack/rspack can't handle this in resolve.alias
+            // e.g. path/to/my/lib/* -> path/to/my/lib
+            [library.name]: library.path.replace(/\/\*$/, ''),
+        }), {}),
+        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 normalModuleReplacementPluginImpl(/./, (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)) {
+                    const newReq = library.name.endsWith('/*')
+                        ? /**
+                           * req usually is in the form of "../../../path/to/file"
+                           * library.path is usually in the form of "/Users/username/path/to/Workspace/path/to/library"
+                           *
+                           * When a wildcard is used in the TS path mappings, we want to get everything after the import to
+                           * re-route the request correctly inline with the webpack/rspack resolve.alias
+                           */
+                            (0, path_1.join)(library.name, req.request.split(library.path.replace(devkit_1.workspaceRoot, '').replace('/*', ''))[1])
+                        : library.name;
+                    req.request = newReq;
+                }
+            }
+        }),
+    };
+}
+/**
+ * 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 };
+}
+/**
+ * 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;
+    }, {});
+}
+/**
+ * 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;
+    }
+}
+/**
+ * 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;
+        }
+    }
+}
+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 {
+        const pkgJsonPath = require.resolve(`${dependency}/package.json`);
+        if (!pkgJsonPath) {
+            throw new Error(`Could not find package ${dependency} when applying it as a shared package. Are you sure it has been installed?`);
+        }
+        const pkgJson = (0, devkit_1.readJsonFile)(pkgJsonPath);
+        const config = getNpmPackageSharedConfig(dependency, pkgJson.version);
+    }
+}
+function getEmptySharedLibrariesConfig(bundler = 'rspack') {
+    const normalModuleReplacementPluginImpl = bundler === 'rspack'
+        ? core_1.NormalModuleReplacementPlugin
+        : require('webpack').NormalModuleReplacementPlugin;
+    return {
+        getAliases: () => ({}),
+        getLibraries: () => ({}),
+        getReplacementPlugin: () => new normalModuleReplacementPluginImpl(/./, () => { }),
+    };
+}

package/src/utils/start-remote-proxies.d.ts

@@ -0,0 +1,5 @@
+import { StaticRemotesConfig } from './parse-static-remotes-config';
+export declare function startRemoteProxies(staticRemotesConfig: StaticRemotesConfig, mappedLocationsOfRemotes: Record<string, string>, sslOptions?: {
+    pathToCert: string;
+    pathToKey: string;
+}): void;

package/src/utils/start-remote-proxies.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startRemoteProxies = startRemoteProxies;
+const devkit_1 = require("@nx/devkit");
+const fs_1 = require("fs");
+function startRemoteProxies(staticRemotesConfig, mappedLocationsOfRemotes, sslOptions) {
+    const { createProxyMiddleware } = require('http-proxy-middleware');
+    const express = require('express');
+    let sslCert;
+    let sslKey;
+    if (sslOptions && sslOptions.pathToCert && sslOptions.pathToKey) {
+        if ((0, fs_1.existsSync)(sslOptions.pathToCert) && (0, fs_1.existsSync)(sslOptions.pathToKey)) {
+            sslCert = (0, fs_1.readFileSync)(sslOptions.pathToCert);
+            sslKey = (0, fs_1.readFileSync)(sslOptions.pathToKey);
+        }
+        else {
+            devkit_1.logger.warn(`Encountered SSL options in project.json, however, the certificate files do not exist in the filesystem. Using http.`);
+            devkit_1.logger.warn(`Attempted to find '${sslOptions.pathToCert}' and '${sslOptions.pathToKey}'.`);
+        }
+    }
+    const http = require('http');
+    const https = require('https');
+    devkit_1.logger.info(`NX Starting static remotes proxies...`);
+    for (const app of staticRemotesConfig.remotes) {
+        const expressProxy = express();
+        expressProxy.use(createProxyMiddleware({
+            target: mappedLocationsOfRemotes[app],
+            changeOrigin: true,
+            secure: sslCert ? false : undefined,
+        }));
+        const proxyServer = (sslCert ? https : http)
+            .createServer({ cert: sslCert, key: sslKey }, expressProxy)
+            .listen(staticRemotesConfig.config[app].port);
+        process.on('SIGTERM', () => proxyServer.close());
+        process.on('exit', () => proxyServer.close());
+    }
+    devkit_1.logger.info(`NX Static remotes proxies started successfully`);
+}

package/src/utils/start-ssr-remote-proxies.d.ts

@@ -0,0 +1,5 @@
+import type { StaticRemotesConfig } from './parse-static-remotes-config';
+export declare function startSsrRemoteProxies(staticRemotesConfig: StaticRemotesConfig, mappedLocationsOfRemotes: Record<string, string>, sslOptions?: {
+    pathToCert: string;
+    pathToKey: string;
+}): void;

package/src/utils/start-ssr-remote-proxies.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startSsrRemoteProxies = startSsrRemoteProxies;
+const devkit_1 = require("@nx/devkit");
+const fs_1 = require("fs");
+function startSsrRemoteProxies(staticRemotesConfig, mappedLocationsOfRemotes, sslOptions) {
+    const { createProxyMiddleware } = require('http-proxy-middleware');
+    const express = require('express');
+    let sslCert;
+    let sslKey;
+    if (sslOptions && sslOptions.pathToCert && sslOptions.pathToKey) {
+        if ((0, fs_1.existsSync)(sslOptions.pathToCert) && (0, fs_1.existsSync)(sslOptions.pathToKey)) {
+            sslCert = (0, fs_1.readFileSync)(sslOptions.pathToCert);
+            sslKey = (0, fs_1.readFileSync)(sslOptions.pathToKey);
+        }
+        else {
+            devkit_1.logger.warn(`Encountered SSL options in project.json, however, the certificate files do not exist in the filesystem. Using http.`);
+            devkit_1.logger.warn(`Attempted to find '${sslOptions.pathToCert}' and '${sslOptions.pathToKey}'.`);
+        }
+    }
+    const http = require('http');
+    const https = require('https');
+    devkit_1.logger.info(`NX Starting static remotes proxies...`);
+    for (const app of staticRemotesConfig.remotes) {
+        const expressProxy = express();
+        /**
+         * SSR remotes have two output paths: one for the browser and one for the server.
+         * We need to handle paths for both of them.
+         * The browser output path is used to serve the client-side code.
+         * The server output path is used to serve the server-side code.
+         */
+        expressProxy.use(createProxyMiddleware({
+            target: `${mappedLocationsOfRemotes[app]}`,
+            secure: sslCert ? false : undefined,
+            changeOrigin: true,
+            pathRewrite: (path) => {
+                if (path.includes('/server')) {
+                    return path;
+                }
+                else {
+                    return `browser/${path}`;
+                }
+            },
+        }));
+        const proxyServer = (sslCert ? https : http)
+            .createServer({ cert: sslCert, key: sslKey }, expressProxy)
+            .listen(staticRemotesConfig.config[app].port);
+        process.on('SIGTERM', () => proxyServer.close());
+        process.on('exit', () => proxyServer.close());
+    }
+    devkit_1.logger.info(`Nx SSR Static remotes proxies started successfully`);
+}

package/src/utils/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/typescript.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readTsPathMappings = readTsPathMappings;
+exports.readTsConfig = readTsConfig;
+exports.getRootTsConfigPath = getRootTsConfigPath;
+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);
+}
+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));
+}
+function getRootTsConfigPath() {
+    const tsConfigFileName = getRootTsConfigFileName();
+    return tsConfigFileName ? (0, path_1.join)(devkit_1.workspaceRoot, tsConfigFileName) : null;
+}
+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/with-module-federation/angular/utils.d.ts

@@ -0,0 +1,15 @@
+import { ModuleFederationConfig, SharedLibraryConfig } from '../../utils';
+export declare function applyDefaultEagerPackages(sharedConfig: Record<string, SharedLibraryConfig>): void;
+export declare const DEFAULT_NPM_PACKAGES_TO_AVOID: string[];
+export declare const DEFAULT_ANGULAR_PACKAGES_TO_SHARE: string[];
+export declare function getFunctionDeterminateRemoteUrl(isServer?: boolean): (remote: string) => string;
+export declare function getModuleFederationConfig(mfConfig: ModuleFederationConfig, options?: {
+    isServer: boolean;
+    determineRemoteUrl?: (remote: string) => string;
+}): Promise<{
+    sharedLibraries: import("../../utils").SharedWorkspaceLibraryConfig;
+    sharedDependencies: {
+        [x: string]: SharedLibraryConfig;
+    };
+    mappedRemotes: Record<string, string>;
+}>;