@nx/module-federation 24.0.0-beta.2 → 24.0.0-beta.3

package/dist/src/utils/share.js

@@ -1,334 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.shareWorkspaceLibraries = shareWorkspaceLibraries;
-exports.getNpmPackageSharedConfig = getNpmPackageSharedConfig;
-exports.filterPackagesDeclaredInRootPackageJson = filterPackagesDeclaredInRootPackageJson;
-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");
-// Deferred so a top-level import of @rspack/core (pure ESM in v2) doesn't
-// crash Jest's CJS loading of any test that imports this module.
-function loadNormalModuleReplacementPlugin(bundler) {
-    if (bundler === 'rspack') {
-        return require('@rspack/core').NormalModuleReplacementPlugin;
-    }
-    return require('webpack').NormalModuleReplacementPlugin;
-}
-/**
- * Checks if a version string is a workspace protocol version that needs normalization.
- * This includes pnpm workspace protocol (workspace:*), file: protocol, or bare *.
- */
-function isWorkspaceProtocolVersion(version) {
-    if (!version)
-        return false;
-    return (version === '*' ||
-        version.startsWith('workspace:') ||
-        version.startsWith('file:'));
-}
-/**
- * Normalizes workspace protocol versions (workspace:*, workspace:^, *, file:) to actual semver versions
- * by looking up the version from the library's package.json.
- *
- * @param version - The version string that may contain workspace protocol
- * @param libraryName - The name of the library to look up
- * @param workspaceLibs - The workspace libraries to search in
- * @returns The normalized version string, or null if it cannot be resolved
- */
-function normalizeWorkspaceProtocolVersion(version, libraryName, workspaceLibs) {
-    if (!isWorkspaceProtocolVersion(version)) {
-        return version;
-    }
-    // Look up the actual version from the library's package.json
-    const workspaceLib = workspaceLibs.find((lib) => lib.importKey === libraryName);
-    if (workspaceLib) {
-        const libPackageJsonPath = (0, path_1.join)(devkit_1.workspaceRoot, workspaceLib.root, 'package.json');
-        if ((0, fs_1.existsSync)(libPackageJsonPath)) {
-            const libPkgJson = (0, devkit_1.readJsonFile)(libPackageJsonPath);
-            if (libPkgJson?.version) {
-                return libPkgJson.version;
-            }
-        }
-    }
-    // Can't resolve the actual version, return null to indicate no version requirement
-    return null;
-}
-/**
- * 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);
-    // 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])),
-        });
-    }
-    // Collect workspace libs that are not in TS path mappings
-    // This supports TS Solution + PM Workspaces where libs use package.json
-    const workspaceLibrariesAsDeps = [];
-    if (Object.keys(sortedTsConfigPathAliases).length !== workspaceLibs.length) {
-        for (const workspaceLib of workspaceLibs) {
-            if (!sortedTsConfigPathAliases[workspaceLib.importKey]) {
-                workspaceLibrariesAsDeps.push(workspaceLib.importKey);
-            }
-        }
-    }
-    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'));
-            }
-            const libraries = pathMappings.reduce((libraries, library) => {
-                // Check to see if the library version is declared in the app's package.json
-                let version = pkgJson
-                    ? (0, devkit_1.getDependencyVersionFromPackageJson)(library.name, devkit_1.workspaceRoot, pkgJson)
-                    : null;
-                // Normalize workspace protocol versions (workspace:*, workspace:^, *, file:)
-                version = normalizeWorkspaceProtocolVersion(version, library.name, workspaceLibs);
-                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,
-                    },
-                };
-            }, {});
-            // Add workspace libs from package.json dependencies
-            // This supports TS Solution + PM Workspaces
-            for (const libraryName of workspaceLibrariesAsDeps) {
-                let version = pkgJson?.dependencies?.[libraryName] ??
-                    pkgJson?.devDependencies?.[libraryName];
-                // Normalize workspace protocol versions (workspace:*, workspace:^, *, file:)
-                version = normalizeWorkspaceProtocolVersion(version, libraryName, workspaceLibs);
-                libraries[libraryName] = {
-                    ...(version
-                        ? { requiredVersion: version, singleton: true }
-                        : { requiredVersion: false }),
-                    eager,
-                };
-            }
-            return libraries;
-        },
-        getReplacementPlugin: () => new (loadNormalModuleReplacementPlugin(bundler))(/./, (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;
-    }
-    // Warn if a workspace protocol version is passed - this indicates the package
-    // should be configured as a workspace library instead of using sharePackages
-    if (isWorkspaceProtocolVersion(version)) {
-        devkit_1.logger.warn(`Package "${pkgName}" has a workspace protocol version "${version}" which cannot be used ` +
-            'for Module Federation. For workspace libraries, use the workspace library configuration ' +
-            'instead of sharePackages. The package will not be shared.');
-        return undefined;
-    }
-    return { singleton: true, strictVersion: true, requiredVersion: version };
-}
-/**
- * Narrow a list of package names down to those with a version declared in the
- * root package.json.
- *
- * Version resolution matches {@link sharePackages}, so a package kept here never
- * trips the missing-version warning in {@link getNpmPackageSharedConfig}.
- * @param packages - Array of package names as strings
- */
-function filterPackagesDeclaredInRootPackageJson(packages) {
-    if (packages.length === 0) {
-        return [];
-    }
-    const pkgJson = (0, package_json_1.readRootPackageJson)();
-    return packages.filter((pkg) => Boolean((0, devkit_1.getDependencyVersionFromPackageJson)(pkg, devkit_1.workspaceRoot, pkgJson)));
-}
-/**
- * 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 = (0, devkit_1.getDependencyVersionFromPackageJson)(pkg, devkit_1.workspaceRoot, pkgJson);
-        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, (0, devkit_1.getDependencyVersionFromPackageJson)(dependency, devkit_1.workspaceRoot, pkgJson));
-        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') {
-    return {
-        getAliases: () => ({}),
-        getLibraries: () => ({}),
-        getReplacementPlugin: () => new (loadNormalModuleReplacementPlugin(bundler))(/./, () => { }),
-    };
-}

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

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

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

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.startRemoteProxies = startRemoteProxies;
-const devkit_1 = require("@nx/devkit");
-const fs_1 = require("fs");
-const port_utils_1 = require("./port-utils");
-async function startRemoteProxies(staticRemotesConfig, mappedLocationsOfRemotes, sslOptions, host = '127.0.0.1') {
-    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...`);
-    let startedProxies = 0;
-    let skippedProxies = 0;
-    for (const app of staticRemotesConfig.remotes) {
-        const port = staticRemotesConfig.config[app].port;
-        // Check if the port is already in use (another MF dev server may have already started a proxy)
-        const portInUse = await (0, port_utils_1.isPortInUse)(port, host);
-        if (portInUse) {
-            devkit_1.logger.info(`NX Skipping proxy for ${app} on port ${port} - port already in use (likely served by another process)`);
-            skippedProxies++;
-            continue;
-        }
-        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(port);
-        process.on('SIGTERM', () => proxyServer.close());
-        process.on('exit', () => proxyServer.close());
-        startedProxies++;
-    }
-    if (skippedProxies > 0) {
-        devkit_1.logger.info(`NX Static remotes proxies: started ${startedProxies}, skipped ${skippedProxies} (already running)`);
-    }
-    else {
-        devkit_1.logger.info(`NX Static remotes proxies started successfully`);
-    }
-}

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

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

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

@@ -1,69 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.startSsrRemoteProxies = startSsrRemoteProxies;
-const devkit_1 = require("@nx/devkit");
-const fs_1 = require("fs");
-const port_utils_1 = require("./port-utils");
-async function startSsrRemoteProxies(staticRemotesConfig, mappedLocationsOfRemotes, sslOptions, host = '127.0.0.1') {
-    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...`);
-    let startedProxies = 0;
-    let skippedProxies = 0;
-    for (const app of staticRemotesConfig.remotes) {
-        const port = staticRemotesConfig.config[app].port;
-        // Check if the port is already in use (another MF dev server may have already started a proxy)
-        const portInUse = await (0, port_utils_1.isPortInUse)(port, host);
-        if (portInUse) {
-            devkit_1.logger.info(`NX Skipping proxy for ${app} on port ${port} - port already in use (likely served by another process)`);
-            skippedProxies++;
-            continue;
-        }
-        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(port);
-        process.on('SIGTERM', () => proxyServer.close());
-        process.on('exit', () => proxyServer.close());
-        startedProxies++;
-    }
-    if (skippedProxies > 0) {
-        devkit_1.logger.info(`NX SSR Static remotes proxies: started ${startedProxies}, skipped ${skippedProxies} (already running)`);
-    }
-    else {
-        devkit_1.logger.info(`Nx SSR Static remotes proxies started successfully`);
-    }
-}

package/dist/src/utils/typescript.d.ts

@@ -1,4 +0,0 @@
-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/dist/src/utils/typescript.js

@@ -1,53 +0,0 @@
-"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));
-    }
-    // Build the processed paths object in a single pass instead of
-    // spreading on each iteration, which was O(n²) for n path aliases
-    const processedPaths = {};
-    for (const [alias, aliasPaths] of Object.entries(tsConfig.get(tsConfigPath).options?.paths ?? {})) {
-        processedPaths[alias] = aliasPaths.map((path) => path.replace(/^\.\//, ''));
-    }
-    tsPathMappings.set(tsConfigPath, processedPaths);
-    return processedPaths;
-}
-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/dist/src/utils/url-helpers.d.ts

@@ -1,13 +0,0 @@
-/**
- * Checks if a URL string is absolute (has protocol)
- */
-export declare function isAbsoluteUrl(url: string): boolean;
-/**
- * Safely processes remote locations, handling both relative and absolute URLs
- * while preserving query parameters and hash fragments for absolute URLs
- */
-export declare function processRemoteLocation(remoteLocation: string, remoteEntryExt: 'js' | 'mjs'): string;
-/**
- * Processes remote URLs for runtime environments, resolving relative URLs against window.location.origin
- */
-export declare function processRuntimeRemoteUrl(remoteUrl: string, remoteEntryExt: 'js' | 'mjs'): string;

package/dist/src/utils/url-helpers.js

@@ -1,70 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAbsoluteUrl = isAbsoluteUrl;
-exports.processRemoteLocation = processRemoteLocation;
-exports.processRuntimeRemoteUrl = processRuntimeRemoteUrl;
-const path_1 = require("path");
-/**
- * Checks if a URL string is absolute (has protocol)
- */
-function isAbsoluteUrl(url) {
-    try {
-        new URL(url);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Safely processes remote locations, handling both relative and absolute URLs
- * while preserving query parameters and hash fragments for absolute URLs
- */
-function processRemoteLocation(remoteLocation, remoteEntryExt) {
-    // Handle promise-based remotes as-is
-    if (remoteLocation.startsWith('promise new Promise')) {
-        return remoteLocation;
-    }
-    if (isAbsoluteUrl(remoteLocation)) {
-        // Use new URL parsing for absolute URLs (supports query params/hash)
-        const url = new URL(remoteLocation);
-        const ext = (0, path_1.extname)(url.pathname);
-        const needsRemoteEntry = !['.js', '.mjs', '.json'].includes(ext);
-        if (needsRemoteEntry) {
-            url.pathname = url.pathname.endsWith('/')
-                ? `${url.pathname}remoteEntry.${remoteEntryExt}`
-                : `${url.pathname}/remoteEntry.${remoteEntryExt}`;
-        }
-        return url.href;
-    }
-    else {
-        // Use string manipulation for relative URLs (backward compatibility)
-        const ext = (0, path_1.extname)(remoteLocation);
-        const needsRemoteEntry = !['.js', '.mjs', '.json'].includes(ext);
-        if (needsRemoteEntry) {
-            const baseRemote = remoteLocation.endsWith('/')
-                ? remoteLocation.slice(0, -1)
-                : remoteLocation;
-            return `${baseRemote}/remoteEntry.${remoteEntryExt}`;
-        }
-        return remoteLocation;
-    }
-}
-/**
- * Processes remote URLs for runtime environments, resolving relative URLs against window.location.origin
- */
-function processRuntimeRemoteUrl(remoteUrl, remoteEntryExt) {
-    if (isAbsoluteUrl(remoteUrl)) {
-        return processRemoteLocation(remoteUrl, remoteEntryExt);
-    }
-    else {
-        // For runtime relative URLs, resolve against current origin
-        const baseUrl = typeof globalThis !== 'undefined' &&
-            typeof globalThis.window !== 'undefined' &&
-            globalThis.window.location
-            ? globalThis.window.location.origin
-            : 'http://localhost';
-        const absoluteUrl = new URL(remoteUrl, baseUrl).href;
-        return processRemoteLocation(absoluteUrl, remoteEntryExt);
-    }
-}

package/dist/src/with-module-federation/angular/utils.d.ts

@@ -1,28 +0,0 @@
-import { ModuleFederationConfig, SharedLibraryConfig } from '../../utils';
-/**
- * Default npm packages to share for Angular projects, each shared only when the
- * workspace declares it in the root package.json.
- */
-export declare const DEFAULT_ANGULAR_PACKAGES_TO_SHARE: string[];
-/**
- * npm packages to avoid sharing in Angular projects.
- */
-export declare const DEFAULT_NPM_PACKAGES_TO_AVOID: string[];
-/**
- * Applies eager loading to default Angular packages.
- * Exported for backward compatibility.
- */
-export declare function applyDefaultEagerPackages(sharedConfig: Record<string, SharedLibraryConfig>, useRspack?: boolean): void;
-/**
- * Creates the default remote URL resolver for Angular.
- * Kept for backward compatibility with existing configs.
- */
-export declare function getFunctionDeterminateRemoteUrl(isServer?: boolean, useRspack?: boolean): (remote: string) => string;
-export declare function getModuleFederationConfig(mfConfig: ModuleFederationConfig, options?: {
-    isServer: boolean;
-    determineRemoteUrl?: (remote: string) => string;
-}, bundler?: 'rspack' | 'webpack'): Promise<import("../../utils/module-federation-config").ModuleFederationConfigResult>;
-export declare function getModuleFederationConfigSync(mfConfig: ModuleFederationConfig, options?: {
-    isServer: boolean;
-    determineRemoteUrl?: (remote: string) => string;
-}, useRspack?: boolean): import("../../utils/module-federation-config").ModuleFederationConfigResult;