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

package/src/utils/ensure-dependencies.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureDependencies = void 0;
+const devkit_1 = require("@nx/devkit");
+const add_swc_dependencies_1 = require("@nx/js/src/utils/swc/add-swc-dependencies");
+const versions_1 = require("./versions");
+function ensureDependencies(tree, options) {
+    const tasks = [];
+    const devDependencies = {};
+    if (options.compiler === 'swc') {
+        devDependencies['swc-loader'] = versions_1.swcLoaderVersion;
+        const addSwcTask = (0, add_swc_dependencies_1.addSwcDependencies)(tree);
+        tasks.push(addSwcTask);
+    }
+    if (options.compiler === 'tsc') {
+        devDependencies['tslib'] = versions_1.tsLibVersion;
+    }
+    if (options.uiFramework === 'react') {
+        devDependencies['@pmmmwh/react-refresh-webpack-plugin'] =
+            versions_1.reactRefreshWebpackPluginVersion;
+        devDependencies['@svgr/webpack'] = versions_1.svgrWebpackVersion;
+        devDependencies['react-refresh'] = versions_1.reactRefreshVersion;
+        devDependencies['url-loader'] = versions_1.urlLoaderVersion;
+    }
+    tasks.push((0, devkit_1.addDependenciesToPackageJson)(tree, {}, devDependencies));
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+exports.ensureDependencies = ensureDependencies;

package/src/utils/fs.d.ts

@@ -0,0 +1,6 @@
+export declare function findUp(names: string | string[], from: string, stopOnNodeModules?: boolean): string;
+export declare function findAllNodeModules(from: string, root?: string): string[];
+/**
+ * Delete an output directory, but error out if it's the root of the project.
+ */
+export declare function deleteOutputDir(root: string, outputPath: string): void;

package/src/utils/fs.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteOutputDir = exports.findAllNodeModules = exports.findUp = void 0;
+const path = require("path");
+const fs_1 = require("fs");
+const fileutils_1 = require("nx/src/utils/fileutils");
+function findUp(names, from, stopOnNodeModules = false) {
+    if (!Array.isArray(names)) {
+        names = [names];
+    }
+    const root = path.parse(from).root;
+    let currentDir = from;
+    while (currentDir && currentDir !== root) {
+        for (const name of names) {
+            const p = path.join(currentDir, name);
+            if ((0, fs_1.existsSync)(p)) {
+                return p;
+            }
+        }
+        if (stopOnNodeModules) {
+            const nodeModuleP = path.join(currentDir, 'node_modules');
+            if ((0, fs_1.existsSync)(nodeModuleP)) {
+                return null;
+            }
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    return null;
+}
+exports.findUp = findUp;
+function findAllNodeModules(from, root) {
+    const nodeModules = [];
+    let current = from;
+    while (current && current !== root) {
+        const potential = path.join(current, 'node_modules');
+        if ((0, fileutils_1.directoryExists)(potential)) {
+            nodeModules.push(potential);
+        }
+        const next = path.dirname(current);
+        if (next === current) {
+            break;
+        }
+        current = next;
+    }
+    return nodeModules;
+}
+exports.findAllNodeModules = findAllNodeModules;
+/**
+ * Delete an output directory, but error out if it's the root of the project.
+ */
+function deleteOutputDir(root, outputPath) {
+    const resolvedOutputPath = path.resolve(root, outputPath);
+    if (resolvedOutputPath === root) {
+        throw new Error('Output path MUST not be project root directory!');
+    }
+    (0, fs_1.rmSync)(resolvedOutputPath, { recursive: true, force: true });
+}
+exports.deleteOutputDir = deleteOutputDir;

package/src/utils/get-client-environment.d.ts

@@ -0,0 +1,5 @@
+export declare function getClientEnvironment(mode?: string): {
+    stringified: {
+        'process.env': {};
+    };
+};

package/src/utils/get-client-environment.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getClientEnvironment = void 0;
+function getClientEnvironment(mode) {
+    // Grab NODE_ENV and NX_* environment variables and prepare them to be
+    // injected into the application via DefinePlugin in webpack configuration.
+    const NX_APP = /^NX_/i;
+    const raw = Object.keys(process.env)
+        .filter((key) => NX_APP.test(key))
+        .reduce((env, key) => {
+        env[key] = process.env[key];
+        return env;
+    }, 
+    // If mode is undefined or is dev or prod then webpack already defines this variable for us.
+    !mode || mode === 'development' || mode === 'production'
+        ? {}
+        : {
+            NODE_ENV: process.env.NODE_ENV,
+        });
+    // Stringify all values so we can feed into webpack DefinePlugin
+    const stringified = {
+        'process.env': Object.keys(raw).reduce((env, key) => {
+            env[key] = JSON.stringify(raw[key]);
+            return env;
+        }, {}),
+    };
+    return { stringified };
+}
+exports.getClientEnvironment = getClientEnvironment;

package/src/utils/get-css-module-local-ident.d.ts

@@ -0,0 +1 @@
+export declare function getCSSModuleLocalIdent(ctx: any, localIdentName: any, localName: any, options: any): any;

package/src/utils/get-css-module-local-ident.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCSSModuleLocalIdent = void 0;
+const path_1 = require("path");
+const loader_utils_1 = require("loader-utils");
+function getCSSModuleLocalIdent(ctx, localIdentName, localName, options) {
+    // Use the filename or folder name, based on some uses the index.js / index.module.(css|scss|sass) project style
+    const fileNameOrFolder = ctx.resourcePath.match(/index\.module\.(css|scss|sass)$/)
+        ? '[folder]'
+        : '[name]';
+    // Create a hash based on a the file location and class name. Will be unique across a project, and close to globally unique.
+    const hash = (0, loader_utils_1.getHashDigest)(path_1.posix.relative(ctx.rootContext, ctx.resourcePath) + localName, 'md5', 'base64', 5);
+    // Use loaderUtils to find the file or folder name
+    const className = (0, loader_utils_1.interpolateName)(ctx, `${fileNameOrFolder}_${localName}__${hash}`, options);
+    // Remove the .module that appears in every classname when based on the file and replace all "." with "_".
+    return className.replace('.module_', '_').replace(/\./g, '_');
+}
+exports.getCSSModuleLocalIdent = getCSSModuleLocalIdent;

package/src/utils/has-plugin.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export declare function hasPlugin(tree: Tree): boolean;

package/src/utils/has-plugin.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasPlugin = void 0;
+const devkit_1 = require("@nx/devkit");
+function hasPlugin(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    return !!nxJson.plugins?.some((p) => typeof p === 'string'
+        ? p === '@nx/webpack/plugin'
+        : p.plugin === '@nx/webpack/plugin');
+}
+exports.hasPlugin = hasPlugin;

package/src/utils/hash-format.d.ts

@@ -0,0 +1,7 @@
+export interface HashFormat {
+    chunk: string;
+    extract: string;
+    file: string;
+    script: string;
+}
+export declare function getOutputHashFormat(option: string, length?: number): HashFormat;

package/src/utils/hash-format.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOutputHashFormat = void 0;
+function getOutputHashFormat(option, length = 20) {
+    const hashFormats = {
+        none: { chunk: '', extract: '', file: '', script: '' },
+        media: { chunk: '', extract: '', file: `.[hash:${length}]`, script: '' },
+        bundles: {
+            chunk: `.[chunkhash:${length}]`,
+            extract: `.[contenthash:${length}]`,
+            file: '',
+            script: `.[contenthash:${length}]`,
+        },
+        all: {
+            chunk: `.[chunkhash:${length}]`,
+            extract: `.[contenthash:${length}]`,
+            file: `.[contenthash:${length}]`,
+            script: `.[contenthash:${length}]`,
+        },
+    };
+    return hashFormats[option] || hashFormats['none'];
+}
+exports.getOutputHashFormat = getOutputHashFormat;

package/src/utils/models.d.ts

@@ -0,0 +1,23 @@
+export type ExtraEntryPoint = ExtraEntryPointClass | string;
+export interface ExtraEntryPointClass {
+    bundleName?: string;
+    inject?: boolean;
+    input: string;
+}
+export type NormalizedEntryPoint = Required<ExtraEntryPointClass>;
+export interface EmittedFile {
+    id?: string;
+    name?: string;
+    file: string;
+    extension: string;
+    initial: boolean;
+    asset?: boolean;
+}
+export interface CreateWebpackConfigOptions<T = any> {
+    root: string;
+    projectRoot: string;
+    sourceRoot?: string;
+    buildOptions: T;
+    tsConfig: any;
+    tsConfigPath: string;
+}

package/src/utils/models.js

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

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,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDependentPackagesForProject = void 0;
+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],
+    };
+}
+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) {
+    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/module-federation/get-remotes-for-host.d.ts

@@ -0,0 +1,14 @@
+import { type ProjectGraph } from '@nx/devkit';
+import { ModuleFederationConfig } from './models/index';
+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: string[];
+    remotePorts: any[];
+};
+export declare function getModuleFederationConfig(tsconfigPath: string, workspaceRoot: string, projectRoot: string, pluginName?: 'react' | 'angular'): any;
+export {};

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

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModuleFederationConfig = exports.getRemotes = void 0;
+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 chalk = require("chalk");
+const path_1 = require("path");
+const fs_1 = require("fs");
+function extractRemoteProjectsFromConfig(config, pathToManifestFile) {
+    const remotes = [];
+    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')) {
+                remotes.push(...Object.keys(parsedManifest));
+            }
+        }
+    }
+    const staticRemotes = config.remotes?.map((r) => (Array.isArray(r) ? r[0] : r)) ?? [];
+    remotes.push(...staticRemotes);
+    return remotes;
+}
+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 remoteProjectRemotes = extractRemoteProjectsFromConfig(remoteProjectConfig);
+    remoteProjectRemotes.forEach((r) => collectRemoteProjects(r, collected, context));
+}
+function getRemotes(devRemotes, skipRemotes, config, context, pathToManifestFile) {
+    const collectedRemotes = new Set();
+    const remotes = 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));
+    devkit_1.logger.info(`NX Starting module federation dev-server for ${chalk.bold(context.projectName)} with ${knownRemotes.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.filter((r) => devServeApps.has(r));
+    const remotePorts = devServeRemotes.map((r) => context.projectGraph.nodes[r].data.targets['serve'].options.port);
+    return {
+        staticRemotes,
+        devRemotes: devServeRemotes,
+        remotePorts,
+    };
+}
+exports.getRemotes = getRemotes;
+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`);
+    }
+}
+exports.getModuleFederationConfig = getModuleFederationConfig;

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

@@ -0,0 +1,6 @@
+export * from './share';
+export * from './dependencies';
+export * from './package-json';
+export * from './remotes';
+export * from './models';
+export * from './get-remotes-for-host';

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

@@ -0,0 +1,9 @@
+"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);

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: (projectRoot: string, eager?: boolean) => Record<string, SharedLibraryConfig>;
+    getReplacementPlugin: () => 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;
+}
+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, 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/module-federation/remotes.js

@@ -0,0 +1,80 @@
+"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, isRemoteGlobal = false) {
+    const mappedRemotes = {};
+    for (const remote of remotes) {
+        if (Array.isArray(remote)) {
+            mappedRemotes[remote[0]] = handleArrayRemote(remote, remoteEntryExt, isRemoteGlobal);
+        }
+        else if (typeof remote === 'string') {
+            mappedRemotes[remote] = handleStringRemote(remote, determineRemoteUrl, isRemoteGlobal);
+        }
+    }
+    return mappedRemotes;
+}
+exports.mapRemotes = mapRemotes;
+// Helper function to deal with remotes that are arrays
+function handleArrayRemote(remote, remoteEntryExt, isRemoteGlobal) {
+    const [remoteName, remoteLocation] = remote;
+    const remoteLocationExt = (0, path_1.extname)(remoteLocation);
+    // If remote location already has .js or .mjs extension
+    if (['.js', '.mjs'].includes(remoteLocationExt)) {
+        return remoteLocation;
+    }
+    const baseRemote = remoteLocation.endsWith('/')
+        ? remoteLocation.slice(0, -1)
+        : remoteLocation;
+    const globalPrefix = isRemoteGlobal
+        ? `${remoteName.replace(/-/g, '_')}@`
+        : '';
+    // 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(remote, determineRemoteUrl, isRemoteGlobal) {
+    const globalPrefix = isRemoteGlobal ? `${remote.replace(/-/g, '_')}@` : '';
+    return `${globalPrefix}${determineRemoteUrl(remote)}`;
+}
+/**
+ * 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;