@nx/module-federation 20.2.0-beta.1 → 20.2.0-beta.3

package/angular.d.ts

@@ -0,0 +1,2 @@
+export * from './src/with-module-federation/angular/with-module-federation';
+export * from './src/with-module-federation/angular/with-module-federation-ssr';

package/angular.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./src/with-module-federation/angular/with-module-federation"), exports);
+tslib_1.__exportStar(require("./src/with-module-federation/angular/with-module-federation-ssr"), exports);

package/index.d.ts

@@ -0,0 +1 @@
+export * from './src/utils/public-api';

package/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./src/utils/public-api"), exports);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nx/module-federation",
   "description": "The Nx Plugin for Module Federation contains executors and utilities that support building applications using Module Federation.",
-  "version": "20.2.0-beta.1",
+  "version": "20.2.0-beta.3",
   "type": "commonjs",
   "repository": {
     "type": "git",
@@ -24,7 +24,17 @@
   "main": "index.js",
   "executors": "./executors.json",
   "dependencies": {
-    "tslib": "^2.3.0"
+    "tslib": "^2.3.0",
+    "@nx/devkit": "20.2.0-beta.3",
+    "@nx/js": "20.2.0-beta.3",
+    "picocolors": "^1.1.0",
+    "webpack": "5.88.0",
+    "@rspack/core": "1.1.2",
+    "@module-federation/enhanced": "0.7.6",
+    "@module-federation/node": "2.6.11",
+    "@module-federation/sdk": "0.7.6",
+    "express": "^4.19.2",
+    "http-proxy-middleware": "^3.0.3"
   },
   "peerDependencies": {},
   "nx-migrations": {
@@ -33,14 +43,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "exports": {
-    "./package.json": "./package.json",
-    ".": {
-      "types": "./index.d.ts",
-      "default": "./index.js"
-    },
-    "./executors.json": "./executors.json",
-    "./migrations.json": "./migrations.json"
-  },
   "types": "./index.d.ts"
 }

package/rspack.d.ts

@@ -0,0 +1,2 @@
+export * from './src/with-module-federation/rspack/with-module-federation';
+export * from './src/with-module-federation/rspack/with-module-federation-ssr';

package/rspack.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./src/with-module-federation/rspack/with-module-federation"), exports);
+tslib_1.__exportStar(require("./src/with-module-federation/rspack/with-module-federation-ssr"), exports);

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDependentPackagesForProject = getDependentPackagesForProject;
+const typescript_1 = require("./typescript");
+const devkit_1 = require("@nx/devkit");
+function getDependentPackagesForProject(projectGraph, name) {
+    const { npmPackages, workspaceLibraries } = collectDependencies(projectGraph, name);
+    return {
+        workspaceLibraries: [...workspaceLibraries.values()],
+        npmPackages: [...npmPackages],
+    };
+}
+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) {
+    let buildLibsFromSource = true;
+    if (process.env.NX_BUILD_LIBS_FROM_SOURCE) {
+        buildLibsFromSource = process.env.NX_BUILD_LIBS_FROM_SOURCE === 'true';
+    }
+    const libraryNode = projectGraph.nodes[library];
+    let sourceRoots = [libraryNode.data.sourceRoot];
+    if (!buildLibsFromSource && process.env.NX_BUILD_TARGET) {
+        const buildTarget = (0, devkit_1.parseTargetString)(process.env.NX_BUILD_TARGET, projectGraph);
+        sourceRoots = (0, devkit_1.getOutputsForTargetAndConfiguration)(buildTarget, {}, libraryNode);
+    }
+    const tsConfigPathMappings = (0, typescript_1.readTsPathMappings)();
+    for (const [key, value] of Object.entries(tsConfigPathMappings)) {
+        for (const src of sourceRoots) {
+            if (value.find((path) => path.startsWith(src))) {
+                return key;
+            }
+        }
+    }
+    return undefined;
+}

package/src/utils/get-remotes-for-host.d.ts

@@ -0,0 +1,16 @@
+import { type ProjectGraph } from '@nx/devkit';
+import { ModuleFederationConfig } from './models';
+interface ModuleFederationExecutorContext {
+    projectName: string;
+    projectGraph: ProjectGraph;
+    root: string;
+}
+export declare function getRemotes(devRemotes: string[], skipRemotes: string[], config: ModuleFederationConfig, context: ModuleFederationExecutorContext, pathToManifestFile?: string): {
+    staticRemotes: string[];
+    devRemotes: any[];
+    dynamicRemotes: any[];
+    remotePorts: any[];
+    staticRemotePort: number;
+};
+export declare function getModuleFederationConfig(tsconfigPath: string, workspaceRoot: string, projectRoot: string, pluginName?: 'react' | 'angular'): any;
+export {};

package/src/utils/get-remotes-for-host.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRemotes = getRemotes;
+exports.getModuleFederationConfig = getModuleFederationConfig;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/js/src/internal");
+const find_matching_projects_1 = require("nx/src/utils/find-matching-projects");
+const pc = require("picocolors");
+const path_1 = require("path");
+const fs_1 = require("fs");
+function extractRemoteProjectsFromConfig(config, pathToManifestFile) {
+    const remotes = [];
+    const dynamicRemotes = [];
+    if (pathToManifestFile && (0, fs_1.existsSync)(pathToManifestFile)) {
+        const moduleFederationManifestJson = (0, fs_1.readFileSync)(pathToManifestFile, 'utf-8');
+        if (moduleFederationManifestJson) {
+            // This should have shape of
+            // {
+            //   "remoteName": "remoteLocation",
+            // }
+            const parsedManifest = JSON.parse(moduleFederationManifestJson);
+            if (Object.keys(parsedManifest).every((key) => typeof key === 'string' && typeof parsedManifest[key] === 'string')) {
+                dynamicRemotes.push(...Object.keys(parsedManifest));
+            }
+        }
+    }
+    const staticRemotes = config.remotes?.map((r) => (Array.isArray(r) ? r[0] : r)) ?? [];
+    remotes.push(...staticRemotes);
+    return { remotes, dynamicRemotes };
+}
+function collectRemoteProjects(remote, collected, context) {
+    const remoteProject = context.projectGraph.nodes[remote]?.data;
+    if (!context.projectGraph.nodes[remote] || collected.has(remote)) {
+        return;
+    }
+    collected.add(remote);
+    const remoteProjectRoot = remoteProject.root;
+    const remoteProjectTsConfig = remoteProject.targets['build'].options.tsConfig;
+    const remoteProjectConfig = getModuleFederationConfig(remoteProjectTsConfig, context.root, remoteProjectRoot);
+    const { remotes: remoteProjectRemotes } = extractRemoteProjectsFromConfig(remoteProjectConfig);
+    remoteProjectRemotes.forEach((r) => collectRemoteProjects(r, collected, context));
+}
+function getRemotes(devRemotes, skipRemotes, config, context, pathToManifestFile) {
+    const collectedRemotes = new Set();
+    const { remotes, dynamicRemotes } = extractRemoteProjectsFromConfig(config, pathToManifestFile);
+    remotes.forEach((r) => collectRemoteProjects(r, collectedRemotes, context));
+    const remotesToSkip = new Set((0, find_matching_projects_1.findMatchingProjects)(skipRemotes, context.projectGraph.nodes) ?? []);
+    if (remotesToSkip.size > 0) {
+        devkit_1.logger.info(`Remotes not served automatically: ${[...remotesToSkip.values()].join(', ')}`);
+    }
+    const knownRemotes = Array.from(collectedRemotes).filter((r) => !remotesToSkip.has(r));
+    const knownDynamicRemotes = dynamicRemotes.filter((r) => !remotesToSkip.has(r) && context.projectGraph.nodes[r]);
+    devkit_1.logger.info(`NX Starting module federation dev-server for ${pc.bold(context.projectName)} with ${[...knownRemotes, ...knownDynamicRemotes].length} remotes`);
+    const devServeApps = new Set(!devRemotes
+        ? []
+        : Array.isArray(devRemotes)
+            ? (0, find_matching_projects_1.findMatchingProjects)(devRemotes, context.projectGraph.nodes)
+            : (0, find_matching_projects_1.findMatchingProjects)([devRemotes], context.projectGraph.nodes));
+    const staticRemotes = knownRemotes.filter((r) => !devServeApps.has(r));
+    const devServeRemotes = [...knownRemotes, ...knownDynamicRemotes].filter((r) => devServeApps.has(r));
+    const staticDynamicRemotes = knownDynamicRemotes.filter((r) => !devServeApps.has(r));
+    const remotePorts = [...devServeRemotes, ...staticDynamicRemotes].map((r) => context.projectGraph.nodes[r].data.targets['serve'].options.port);
+    const staticRemotePort = Math.max(...[
+        ...remotePorts,
+        ...staticRemotes.map((r) => context.projectGraph.nodes[r].data.targets['serve'].options.port),
+    ]) +
+        (remotesToSkip.size + 1);
+    return {
+        staticRemotes,
+        devRemotes: devServeRemotes,
+        dynamicRemotes: staticDynamicRemotes,
+        remotePorts,
+        staticRemotePort,
+    };
+}
+function getModuleFederationConfig(tsconfigPath, workspaceRoot, projectRoot, pluginName = 'react') {
+    const moduleFederationConfigPathJS = (0, path_1.join)(workspaceRoot, projectRoot, 'module-federation.config.js');
+    const moduleFederationConfigPathTS = (0, path_1.join)(workspaceRoot, projectRoot, 'module-federation.config.ts');
+    let moduleFederationConfigPath = moduleFederationConfigPathJS;
+    // create a no-op so this can be called with issue
+    const fullTSconfigPath = tsconfigPath.startsWith(workspaceRoot)
+        ? tsconfigPath
+        : (0, path_1.join)(workspaceRoot, tsconfigPath);
+    let cleanupTranspiler = () => { };
+    if ((0, fs_1.existsSync)(moduleFederationConfigPathTS)) {
+        cleanupTranspiler = (0, internal_1.registerTsProject)(fullTSconfigPath);
+        moduleFederationConfigPath = moduleFederationConfigPathTS;
+    }
+    try {
+        const config = require(moduleFederationConfigPath);
+        cleanupTranspiler();
+        return config.default || config;
+    }
+    catch {
+        throw new Error(`Could not load ${moduleFederationConfigPath}. Was this project generated with "@nx/${pluginName}:host"?\nSee: https://nx.dev/concepts/more-concepts/faster-builds-with-module-federation`);
+    }
+}

package/src/utils/index.d.ts

@@ -0,0 +1,9 @@
+export * from './share';
+export * from './dependencies';
+export * from './package-json';
+export * from './remotes';
+export * from './models';
+export * from './get-remotes-for-host';
+export * from './parse-static-remotes-config';
+export * from './start-remote-proxies';
+export * from './start-ssr-remote-proxies';

package/src/utils/index.js

@@ -0,0 +1,12 @@
+"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);
+tslib_1.__exportStar(require("./get-remotes-for-host"), exports);
+tslib_1.__exportStar(require("./parse-static-remotes-config"), exports);
+tslib_1.__exportStar(require("./start-remote-proxies"), exports);
+tslib_1.__exportStar(require("./start-ssr-remote-proxies"), exports);

package/src/utils/models/index.d.ts

@@ -0,0 +1,47 @@
+import type { moduleFederationPlugin } from '@module-federation/sdk';
+import type { NormalModuleReplacementPlugin as RspackNormalModuleReplacementPlugin } from '@rspack/core';
+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: (projectRoot: string, eager?: boolean) => Record<string, SharedLibraryConfig>;
+    getReplacementPlugin: () => RspackNormalModuleReplacementPlugin | import('webpack').NormalModuleReplacementPlugin;
+};
+export type Remotes = Array<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;
+    /**
+     * `nxRuntimeLibraryControlPlugin` is a runtime module federation plugin to ensure
+     * that shared libraries are resolved from a remote with live reload capabilities.
+     * If you run into any issues with loading shared libraries, try disabling this option.
+     */
+    disableNxRuntimeLibraryControlPlugin?: boolean;
+}
+export type NxModuleFederationConfigOverride = Omit<moduleFederationPlugin.ModuleFederationPluginOptions, 'exposes' | 'remotes' | 'name' | 'shared' | 'filename'>;
+export type WorkspaceLibrarySecondaryEntryPoint = {
+    name: string;
+    path: string;
+};

package/src/utils/models/index.js

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

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

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

package/src/utils/package-json.js

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

package/src/utils/parse-static-remotes-config.d.ts

@@ -0,0 +1,13 @@
+import type { ExecutorContext } from '@nx/devkit';
+export type StaticRemoteConfig = {
+    basePath: string;
+    outputPath: string;
+    urlSegment: string;
+    port: number;
+};
+export type StaticRemotesConfig = {
+    remotes: string[];
+    config: Record<string, StaticRemoteConfig> | undefined;
+};
+export declare function parseStaticRemotesConfig(staticRemotes: string[] | undefined, context: ExecutorContext): StaticRemotesConfig;
+export declare function parseStaticSsrRemotesConfig(staticRemotes: string[] | undefined, context: ExecutorContext): StaticRemotesConfig;

package/src/utils/parse-static-remotes-config.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStaticRemotesConfig = parseStaticRemotesConfig;
+exports.parseStaticSsrRemotesConfig = parseStaticSsrRemotesConfig;
+const path_1 = require("path");
+function parseStaticRemotesConfig(staticRemotes, context) {
+    if (!staticRemotes?.length) {
+        return { remotes: [], config: undefined };
+    }
+    const config = {};
+    for (const app of staticRemotes) {
+        const outputPath = context.projectGraph.nodes[app].data.targets['build'].options.outputPath;
+        const basePath = (0, path_1.dirname)(outputPath);
+        const urlSegment = (0, path_1.basename)(outputPath);
+        const port = context.projectGraph.nodes[app].data.targets['serve'].options.port;
+        config[app] = { basePath, outputPath, urlSegment, port };
+    }
+    return { remotes: staticRemotes, config };
+}
+function parseStaticSsrRemotesConfig(staticRemotes, context) {
+    if (!staticRemotes?.length) {
+        return { remotes: [], config: undefined };
+    }
+    const config = {};
+    for (const app of staticRemotes) {
+        const outputPath = (0, path_1.dirname)(context.projectGraph.nodes[app].data.targets['build'].options.outputPath // dist/checkout/browser -> checkout
+        );
+        const basePath = (0, path_1.dirname)(outputPath); // dist/checkout -> dist
+        const urlSegment = (0, path_1.basename)(outputPath); // dist/checkout -> checkout
+        const port = context.projectGraph.nodes[app].data.targets['serve'].options.port;
+        config[app] = { basePath, outputPath, urlSegment, port };
+    }
+    return { remotes: staticRemotes, config };
+}

package/src/utils/plugins/runtime-library-control.plugin.d.ts

@@ -0,0 +1,3 @@
+import type { FederationRuntimePlugin } from '@module-federation/enhanced/runtime';
+declare const nxRuntimeLibraryControlPlugin: () => FederationRuntimePlugin;
+export default nxRuntimeLibraryControlPlugin;

package/src/utils/plugins/runtime-library-control.plugin.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const runtimeStore = {
+    sharedPackagesFromDev: {},
+};
+if (process.env.NX_MF_DEV_REMOTES) {
+    // process.env.NX_MF_DEV_REMOTES is replaced by an array value via DefinePlugin, even though the original value is a stringified array.
+    runtimeStore.devRemotes = process.env
+        .NX_MF_DEV_REMOTES;
+}
+const nxRuntimeLibraryControlPlugin = function () {
+    return {
+        name: 'nx-runtime-library-control-plugin',
+        beforeInit(args) {
+            runtimeStore.name = args.options.name;
+            return args;
+        },
+        resolveShare: (args) => {
+            const { shareScopeMap, scope, pkgName, version, GlobalFederation } = args;
+            const originalResolver = args.resolver;
+            args.resolver = function () {
+                if (!runtimeStore.sharedPackagesFromDev[pkgName]) {
+                    if (!GlobalFederation.__INSTANCES__) {
+                        return originalResolver();
+                    }
+                    else if (!runtimeStore.devRemotes) {
+                        return originalResolver();
+                    }
+                    const devRemoteInstanceToUse = GlobalFederation.__INSTANCES__.find((instance) => instance.options.shared[pkgName] &&
+                        runtimeStore.devRemotes.find((dr) => instance.name === dr));
+                    if (!devRemoteInstanceToUse) {
+                        return originalResolver();
+                    }
+                    runtimeStore.sharedPackagesFromDev[pkgName] =
+                        devRemoteInstanceToUse.name;
+                }
+                const remoteInstanceName = runtimeStore.sharedPackagesFromDev[pkgName];
+                const remoteInstance = GlobalFederation.__INSTANCES__.find((instance) => instance.name === remoteInstanceName);
+                try {
+                    const remotePkgInfo = remoteInstance.options.shared[pkgName].find((shared) => shared.from === remoteInstanceName);
+                    remotePkgInfo.useIn.push(runtimeStore.name);
+                    remotePkgInfo.useIn = Array.from(new Set(remotePkgInfo.useIn));
+                    shareScopeMap[scope][pkgName][version] = remotePkgInfo;
+                    return remotePkgInfo;
+                }
+                catch {
+                    return originalResolver();
+                }
+            };
+            return args;
+        },
+    };
+};
+exports.default = nxRuntimeLibraryControlPlugin;

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

@@ -0,0 +1,6 @@
+import { AdditionalSharedConfig, ModuleFederationConfig, ModuleFederationLibrary, NxModuleFederationConfigOverride, 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, NxModuleFederationConfigOverride, SharedLibraryConfig, SharedWorkspaceLibraryConfig, AdditionalSharedConfig, WorkspaceLibrary, SharedFunction, WorkspaceLibrarySecondaryEntryPoint, Remotes, ModuleFederationLibrary, applySharedFunction, applyAdditionalShared, getNpmPackageSharedConfig, shareWorkspaceLibraries, sharePackages, mapRemotes, mapRemotesForSSR, getDependentPackagesForProject, readRootPackageJson, };

package/src/utils/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/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, isRemoteGlobal?: boolean): 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/remotes.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapRemotes = mapRemotes;
+exports.mapRemotesForSSR = mapRemotesForSSR;
+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, isRemoteGlobal = false) {
+    const mappedRemotes = {};
+    for (const nxRemoteProjectName of remotes) {
+        if (Array.isArray(nxRemoteProjectName)) {
+            const mfRemoteName = normalizeRemoteName(nxRemoteProjectName[0]);
+            mappedRemotes[mfRemoteName] = handleArrayRemote(nxRemoteProjectName, remoteEntryExt, isRemoteGlobal);
+        }
+        else if (typeof nxRemoteProjectName === 'string') {
+            const mfRemoteName = normalizeRemoteName(nxRemoteProjectName);
+            mappedRemotes[mfRemoteName] = handleStringRemote(nxRemoteProjectName, determineRemoteUrl, isRemoteGlobal);
+        }
+    }
+    return mappedRemotes;
+}
+// Helper function to deal with remotes that are arrays
+function handleArrayRemote(remote, remoteEntryExt, isRemoteGlobal) {
+    let [nxRemoteProjectName, remoteLocation] = remote;
+    const mfRemoteName = normalizeRemoteName(nxRemoteProjectName);
+    const remoteLocationExt = (0, path_1.extname)(remoteLocation);
+    // If remote location already has .js or .mjs extension
+    if (['.js', '.mjs', '.json'].includes(remoteLocationExt)) {
+        return remoteLocation;
+    }
+    const baseRemote = remoteLocation.endsWith('/')
+        ? remoteLocation.slice(0, -1)
+        : remoteLocation;
+    const globalPrefix = isRemoteGlobal
+        ? `${normalizeRemoteName(nxRemoteProjectName)}@`
+        : '';
+    // if the remote is defined with anything other than http then we assume it's a promise based remote
+    // In that case we should use what the user provides as the remote location
+    if (!remoteLocation.startsWith('promise new Promise')) {
+        return `${globalPrefix}${baseRemote}/remoteEntry.${remoteEntryExt}`;
+    }
+    else {
+        return remoteLocation;
+    }
+}
+// Helper function to deal with remotes that are strings
+function handleStringRemote(nxRemoteProjectName, determineRemoteUrl, isRemoteGlobal) {
+    const globalPrefix = isRemoteGlobal
+        ? `${normalizeRemoteName(nxRemoteProjectName)}@`
+        : '';
+    return `${globalPrefix}${determineRemoteUrl(nxRemoteProjectName)}`;
+}
+/**
+ * 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)) {
+            let [nxRemoteProjectName, remoteLocation] = remote;
+            const mfRemoteName = normalizeRemoteName(nxRemoteProjectName);
+            const remoteLocationExt = (0, path_1.extname)(remoteLocation);
+            mappedRemotes[mfRemoteName] = `${mfRemoteName}@${['.js', '.mjs', '.json'].includes(remoteLocationExt)
+                ? remoteLocation
+                : `${remoteLocation.endsWith('/')
+                    ? remoteLocation.slice(0, -1)
+                    : remoteLocation}/remoteEntry.${remoteEntryExt}`}`;
+        }
+        else if (typeof remote === 'string') {
+            const mfRemoteName = normalizeRemoteName(remote);
+            mappedRemotes[mfRemoteName] = `${mfRemoteName}@${determineRemoteUrl(remote)}`;
+        }
+    }
+    return mappedRemotes;
+}
+function normalizeRemoteName(remote) {
+    return remote.replace(/-/g, '_');
+}

package/src/utils/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;