@module-federation/esbuild 0.0.0-next-20240523224941

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-present zhouxiao(zhoushaw)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,117 @@
+Here's an updated README.md that incorporates the plugin options and ensures they are met:
+
+
+# @module-federation/esbuild
+
+This package provides an esbuild plugin for Module Federation, enabling you to easily share code between independently built and deployed applications.
+
+## Installation
+
+Install the package using npm:
+
+```bash
+npm install @module-federation/esbuild
+```
+
+## Usage
+
+To use the Module Federation plugin with esbuild, add it to your esbuild configuration:
+
+```js
+const esbuild = require('esbuild');
+const path = require('path');
+const fs = require('fs');
+const { moduleFederationPlugin } = require('@module-federation/esbuild/esbuild-adapter');
+const { federationBuilder } = require('@module-federation/esbuild/build');
+
+async function build() {
+  const tsConfig = 'tsconfig.json';
+  const outputPath = path.join('dist', 'host');
+
+  await federationBuilder.init({
+    options: {
+      workspaceRoot: path.join(__dirname, '..'),
+      outputPath,
+      tsConfig,
+      federationConfig: path.join('host', 'federation.config.js'),
+      verbose: false,
+      watch: false,
+    },
+  });
+
+  await esbuild.build({
+    entryPoints: [path.join('host', 'main.ts')],
+    external: federationBuilder.externals,
+    outdir: outputPath,
+    bundle: true,
+    platform: 'browser',
+    format: 'esm',
+    mainFields: ['es2020', 'browser', 'module', 'main'],
+    conditions: ['es2020', 'es2015', 'module'],
+    resolveExtensions: ['.ts', '.tsx', '.mjs', '.js'],
+    tsconfig: tsConfig,
+    splitting: true,
+    plugins: [moduleFederationPlugin(federationBuilder)],
+  });
+}
+
+build().catch((err) => {
+  console.error(err);
+  process.exit(1);
+}
+
+// Example of federation.config.js
+
+const { withFederation, shareAll } = require('@module-federation/esbuild/build');
+
+module.exports = withFederation({
+  name: 'host',
+  filename: 'remoteEntry.js',
+  exposes: {
+    './Component': './src/Component',
+  },
+  shared: {
+    ...shareAll({
+      singleton: true,
+      strictVersion: true,
+      requiredVersion: 'auto',
+      includeSecondaries: false,
+    }),
+  },
+});
+
+```
+
+The `moduleFederationPlugin` accepts a configuration object with the following properties:
+
+- `name` (string): The name of the host application.
+- `filename` (string, optional): The name of the remote entry file. Defaults to `'remoteEntry.js'`.
+- `remotes` (object, optional): An object specifying the remote applications and their entry points.
+- `exposes` (object, optional): An object specifying the modules to be exposed by the host application.
+- `shared` (array, optional): An array of package names to be shared between the host and remote applications.
+
+## Plugin Features
+
+The `moduleFederationPlugin` includes the following features:
+
+- **Virtual Share Module**: Creates a virtual module for sharing dependencies between the host and remote applications.
+- **Virtual Remote Module**: Creates a virtual module for importing exposed modules from remote applications.
+- **CommonJS to ESM Transformation**: Transforms CommonJS modules to ESM format for compatibility with Module Federation.
+- **Shared Dependencies Linking**: Links shared dependencies between the host and remote applications.
+- **Manifest Generation**: Generates a manifest file containing information about the exposed modules and their exports.
+
+## API
+
+### `moduleFederationPlugin(config)`
+
+Creates an esbuild plugin for Module Federation.
+
+- `config` (object): The Module Federation configuration.
+  - `name` (string): The name of the host application.
+  - `filename` (string, optional): The name of the remote entry file. Defaults to `'remoteEntry.js'`.
+  - `remotes` (object, optional): An object specifying the remote applications and their entry points.
+  - `exposes` (object, optional): An object specifying the modules to be exposed by the host application.
+  - `shared` (array, optional): An array of package names to be shared between the host and remote applications.
+
+Returns an esbuild plugin instance.
+

package/dist/build.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./src/build";

package/dist/build.cjs.js

@@ -0,0 +1,450 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var federationBuilder = require('./federation-builder.cjs.js');
+var path = require('path');
+var fs = require('fs');
+var process = require('process');
+var JSON5 = require('json5');
+var crypto = require('crypto');
+require('npmlog');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var process__default = /*#__PURE__*/_interopDefaultLegacy(process);
+var JSON5__namespace = /*#__PURE__*/_interopNamespace(JSON5);
+var crypto__namespace = /*#__PURE__*/_interopNamespace(crypto);
+
+const DEFAULT_SKIP_LIST = [
+    '@module-federation/native-federation-runtime',
+    '@module-federation/native-federation',
+    '@module-federation/native-federation-core',
+    '@module-federation/native-federation-esbuild',
+    '@angular-architects/native-federation',
+    '@angular-architects/native-federation-runtime',
+    'es-module-shims',
+    'zone.js',
+    'tslib/',
+    '@angular/localize',
+    '@angular/localize/init',
+    '@angular/localize/tools',
+    '@angular/platform-server',
+    '@angular/platform-server/init',
+    '@angular/ssr',
+    'express',
+    /\/schematics(\/|$)/,
+    /^@nx\/angular/,
+    (pkg)=>pkg.startsWith('@angular/') && !!pkg.match(/\/testing(\/|$)/),
+    (pkg)=>pkg.startsWith('@types/')
+];
+const PREPARED_DEFAULT_SKIP_LIST = prepareSkipList(DEFAULT_SKIP_LIST);
+function prepareSkipList(skipList) {
+    return {
+        strings: new Set(skipList.filter((e)=>typeof e === 'string')),
+        functions: skipList.filter((e)=>typeof e === 'function'),
+        regexps: skipList.filter((e)=>typeof e === 'object')
+    };
+}
+function isInSkipList(entry, skipList) {
+    if (skipList.strings.has(entry)) {
+        return true;
+    }
+    if (skipList.functions.find((f)=>f(entry))) {
+        return true;
+    }
+    if (skipList.regexps.find((r)=>r.test(entry))) {
+        return true;
+    }
+    return false;
+}
+
+let inferVersion = false;
+const DEFAULT_SECONARIES_SKIP_LIST = [
+    '@angular/router/upgrade',
+    '@angular/common/upgrade'
+];
+function findRootTsConfigJson() {
+    const packageJson = findPackageJson(process__default["default"].cwd());
+    const projectRoot = path__default["default"].dirname(packageJson);
+    const tsConfigBaseJson = path__default["default"].join(projectRoot, 'tsconfig.base.json');
+    const tsConfigJson = path__default["default"].join(projectRoot, 'tsconfig.json');
+    if (fs__default["default"].existsSync(tsConfigBaseJson)) {
+        return tsConfigBaseJson;
+    } else if (fs__default["default"].existsSync(tsConfigJson)) {
+        return tsConfigJson;
+    }
+    throw new Error('Neither a tsconfig.json nor a tsconfig.base.json was found');
+}
+function findPackageJson(folder) {
+    while(!fs__default["default"].existsSync(path__default["default"].join(folder, 'package.json')) && path__default["default"].dirname(folder) !== folder){
+        folder = path__default["default"].dirname(folder);
+    }
+    const filePath = path__default["default"].join(folder, 'package.json');
+    if (fs__default["default"].existsSync(filePath)) {
+        return filePath;
+    }
+    throw new Error('no package.json found. Searched the following folder and all parents: ' + folder);
+}
+function lookupVersion(key, workspaceRoot) {
+    const versionMaps = federationBuilder.getVersionMaps(workspaceRoot, workspaceRoot);
+    for (const versionMap of versionMaps){
+        const version = lookupVersionInMap(key, versionMap);
+        if (version) {
+            return version;
+        }
+    }
+    throw new Error(`Shared Dependency ${key} has requiredVersion:'auto'. However, this dependency is not found in your package.json`);
+}
+function lookupVersionInMap(key, versions) {
+    const parts = key.split('/');
+    if (parts.length >= 2 && parts[0].startsWith('@')) {
+        key = parts[0] + '/' + parts[1];
+    } else {
+        key = parts[0];
+    }
+    if (key.toLowerCase() === '@angular-architects/module-federation-runtime') {
+        key = '@angular-architects/module-federation';
+    }
+    if (!versions[key]) {
+        return null;
+    }
+    return versions[key];
+}
+function _findSecondaries(libPath, excludes, shareObject, acc) {
+    const files = fs__default["default"].readdirSync(libPath);
+    const dirs = files.map((f)=>path__default["default"].join(libPath, f)).filter((f)=>fs__default["default"].lstatSync(f).isDirectory() && f !== 'node_modules');
+    const secondaries = dirs.filter((d)=>fs__default["default"].existsSync(path__default["default"].join(d, 'package.json')));
+    for (const s of secondaries){
+        const secondaryLibName = s.replace(/\\/g, '/').replace(/^.*node_modules[/]/, '');
+        if (excludes.includes(secondaryLibName)) {
+            continue;
+        }
+        if (isInSkipList(secondaryLibName, PREPARED_DEFAULT_SKIP_LIST)) {
+            continue;
+        }
+        acc[secondaryLibName] = Object.assign({}, shareObject);
+        _findSecondaries(s, excludes, shareObject, acc);
+    }
+}
+function findSecondaries(libPath, excludes, shareObject) {
+    const acc = {};
+    _findSecondaries(libPath, excludes, shareObject, acc);
+    return acc;
+}
+function getSecondaries(includeSecondaries, libPath, key, shareObject) {
+    let exclude = [
+        ...DEFAULT_SECONARIES_SKIP_LIST
+    ];
+    if (typeof includeSecondaries === 'object') {
+        if (Array.isArray(includeSecondaries.skip)) {
+            exclude = includeSecondaries.skip;
+        } else if (typeof includeSecondaries.skip === 'string') {
+            exclude = [
+                includeSecondaries.skip
+            ];
+        }
+    }
+    if (!fs__default["default"].existsSync(libPath)) {
+        return {};
+    }
+    const configured = readConfiguredSecondaries(key, libPath, exclude, shareObject);
+    if (configured) {
+        return configured;
+    }
+    // Fallback: Search folders
+    const secondaries = findSecondaries(libPath, exclude, shareObject);
+    return secondaries;
+}
+function readConfiguredSecondaries(parent, libPath, exclude, shareObject) {
+    const libPackageJson = path__default["default"].join(libPath, 'package.json');
+    if (!fs__default["default"].existsSync(libPackageJson)) {
+        return null;
+    }
+    const packageJson = JSON.parse(fs__default["default"].readFileSync(libPackageJson, 'utf-8'));
+    const exports = packageJson['exports'];
+    if (!exports) {
+        return null;
+    }
+    const keys = Object.keys(exports).filter((key)=>key != '.' && key != './package.json' && !key.endsWith('*') && (exports[key]['default'] || typeof exports[key] === 'string'));
+    const result = {};
+    for (const key of keys){
+        // const relPath = exports[key]['default'];
+        const secondaryName = path__default["default"].join(parent, key).replace(/\\/g, '/');
+        if (exclude.includes(secondaryName)) {
+            continue;
+        }
+        if (isInSkipList(secondaryName, PREPARED_DEFAULT_SKIP_LIST)) {
+            continue;
+        }
+        const entry = getDefaultEntry(exports, key);
+        if (typeof entry !== 'string') {
+            console.log('No entry point found for ' + secondaryName);
+            continue;
+        }
+        if ((entry === null || entry === void 0 ? void 0 : entry.endsWith('.css')) || (entry === null || entry === void 0 ? void 0 : entry.endsWith('.scss')) || (entry === null || entry === void 0 ? void 0 : entry.endsWith('.less'))) {
+            continue;
+        }
+        result[secondaryName] = Object.assign({}, shareObject);
+    }
+    return result;
+}
+function getDefaultEntry(exports, key) {
+    var _a;
+    let entry = '';
+    if (typeof exports[key] === 'string') {
+        entry = exports[key];
+    } else {
+        entry = (_a = exports[key]) === null || _a === void 0 ? void 0 : _a['default'];
+        if (typeof entry === 'object') {
+            entry = entry['default'];
+        }
+    }
+    return entry;
+}
+function shareAll(config = {}, skip = DEFAULT_SKIP_LIST, projectPath = '') {
+    // let workspacePath: string | undefined = undefined;
+    projectPath = inferProjectPath(projectPath);
+    // workspacePath = getConfigContext().workspaceRoot ?? '';
+    // if (!workspacePath) {
+    //   workspacePath = projectPath;
+    // }
+    const versionMaps = federationBuilder.getVersionMaps(projectPath, projectPath);
+    const share = {};
+    for (const versions of versionMaps){
+        const preparedSkipList = prepareSkipList(skip);
+        for(const key in versions){
+            if (isInSkipList(key, preparedSkipList)) {
+                continue;
+            }
+            const inferVersion = !config.requiredVersion || config.requiredVersion === 'auto';
+            const requiredVersion = inferVersion ? versions[key] : config.requiredVersion;
+            if (!share[key]) {
+                share[key] = Object.assign(Object.assign({}, config), {
+                    requiredVersion
+                });
+            }
+        }
+    }
+    return module.exports.share(share, projectPath);
+}
+function inferProjectPath(projectPath) {
+    if (!projectPath && federationBuilder.getConfigContext().packageJson) {
+        projectPath = path__default["default"].dirname(federationBuilder.getConfigContext().packageJson || '');
+    }
+    if (!projectPath && federationBuilder.getConfigContext().workspaceRoot) {
+        projectPath = federationBuilder.getConfigContext().workspaceRoot || '';
+    }
+    if (!projectPath) {
+        projectPath = process__default["default"].cwd();
+    }
+    return projectPath;
+}
+function setInferVersion(infer) {
+    inferVersion = infer;
+}
+function share(shareObjects, projectPath = '') {
+    projectPath = inferProjectPath(projectPath);
+    const packagePath = findPackageJson(projectPath);
+    // const versions = readVersionMap(packagePath);
+    const result = {};
+    let includeSecondaries;
+    for(const key in shareObjects){
+        includeSecondaries = false;
+        const shareObject = shareObjects[key];
+        if (shareObject.requiredVersion === 'auto' || inferVersion && typeof shareObject.requiredVersion === 'undefined') {
+            const version = lookupVersion(key, projectPath);
+            shareObject.requiredVersion = version;
+            shareObject.version = version.replace(/^\D*/, '');
+        }
+        if (typeof shareObject.includeSecondaries === 'undefined') {
+            shareObject.includeSecondaries = true;
+        }
+        if (shareObject.includeSecondaries) {
+            includeSecondaries = shareObject.includeSecondaries;
+            delete shareObject.includeSecondaries;
+        }
+        result[key] = shareObject;
+        if (includeSecondaries) {
+            const libPackageJson = federationBuilder.findDepPackageJson(key, path__default["default"].dirname(packagePath));
+            if (!libPackageJson) {
+                federationBuilder.logger.error('Could not find folder containing dep ' + key);
+                continue;
+            }
+            const libPath = path__default["default"].dirname(libPackageJson);
+            const secondaries = getSecondaries(includeSecondaries, libPath, key, shareObject);
+            if (secondaries) {
+                addSecondaries(secondaries, result);
+            }
+        }
+    }
+    return result;
+}
+function addSecondaries(secondaries, result) {
+    for(const key in secondaries){
+        result[key] = secondaries[key];
+    }
+}
+
+function getMappedPaths({ rootTsConfigPath, sharedMappings, rootPath }) {
+    var _tsConfig_compilerOptions;
+    const result = [];
+    if (!path__namespace.isAbsolute(rootTsConfigPath)) {
+        throw new Error('SharedMappings.register: tsConfigPath needs to be an absolute path!');
+    }
+    if (!rootPath) {
+        rootPath = path__namespace.normalize(path__namespace.dirname(rootTsConfigPath));
+    }
+    const shareAll = !sharedMappings;
+    if (!sharedMappings) {
+        sharedMappings = [];
+    }
+    const tsConfig = JSON5__namespace.parse(fs__namespace.readFileSync(rootTsConfigPath, {
+        encoding: 'utf-8'
+    }));
+    const mappings = tsConfig == null ? void 0 : (_tsConfig_compilerOptions = tsConfig.compilerOptions) == null ? void 0 : _tsConfig_compilerOptions.paths;
+    if (!mappings) {
+        return result;
+    }
+    for(const key in mappings){
+        const libPath = path__namespace.normalize(path__namespace.join(rootPath, mappings[key][0]));
+        if (sharedMappings.includes(key) || shareAll) {
+            result.push({
+                key,
+                path: libPath
+            });
+        }
+    }
+    return result;
+}
+
+function _extends() {
+    _extends = Object.assign || function(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source){
+                if (Object.prototype.hasOwnProperty.call(source, key)) {
+                    target[key] = source[key];
+                }
+            }
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+function withFederation(config) {
+    var _config_skip;
+    const skip = prepareSkipList((_config_skip = config.skip) != null ? _config_skip : []);
+    var _config_name, _config_filename, _config_exposes, _config_remotes;
+    return {
+        name: (_config_name = config.name) != null ? _config_name : '',
+        filename: (_config_filename = config.filename) != null ? _config_filename : 'remoteEntry',
+        exposes: (_config_exposes = config.exposes) != null ? _config_exposes : {},
+        remotes: (_config_remotes = config.remotes) != null ? _config_remotes : {},
+        shared: normalizeShared(config, skip),
+        sharedMappings: normalizeSharedMappings(config, skip)
+    };
+}
+function normalizeShared(config, skip) {
+    let result = {};
+    const shared = config.shared;
+    if (!shared) {
+        result = shareAll({
+            singleton: true,
+            strictVersion: true,
+            requiredVersion: 'auto'
+        });
+    } else {
+        result = Object.keys(shared).reduce((acc, cur)=>{
+            var _shared_cur_requiredVersion, _shared_cur_singleton, _shared_cur_strictVersion;
+            return _extends({}, acc, {
+                [cur]: {
+                    requiredVersion: (_shared_cur_requiredVersion = shared[cur].requiredVersion) != null ? _shared_cur_requiredVersion : 'auto',
+                    singleton: (_shared_cur_singleton = shared[cur].singleton) != null ? _shared_cur_singleton : false,
+                    strictVersion: (_shared_cur_strictVersion = shared[cur].strictVersion) != null ? _shared_cur_strictVersion : false,
+                    version: shared[cur].version,
+                    includeSecondaries: shared[cur].includeSecondaries
+                }
+            });
+        }, {});
+    }
+    result = Object.keys(result).filter((key)=>!isInSkipList(key, skip)).reduce((acc, cur)=>_extends({}, acc, {
+            [cur]: result[cur]
+        }), {});
+    return result;
+}
+function normalizeSharedMappings(config, skip) {
+    const rootTsConfigPath = findRootTsConfigJson();
+    const paths = getMappedPaths({
+        rootTsConfigPath,
+        sharedMappings: config.sharedMappings
+    });
+    const result = paths.filter((p)=>!isInSkipList(p.key, skip) && !p.key.includes('*'));
+    if (paths.find((p)=>p.key.includes('*'))) {
+        federationBuilder.logger.warn('Sharing mapped paths with wildcards (*) not supported');
+    }
+    return result;
+}
+
+function hashFile(fileName) {
+    const fileBuffer = fs__namespace.readFileSync(fileName);
+    const hashSum = crypto__namespace.createHash('md5');
+    hashSum.update(fileBuffer);
+    return hashSum.digest('hex');
+}
+
+exports.buildForFederation = federationBuilder.buildForFederation;
+exports.bundleExposedAndMappings = federationBuilder.bundleExposedAndMappings;
+exports.createBuildResultMap = federationBuilder.createBuildResultMap;
+exports.defaultBuildParams = federationBuilder.defaultBuildParams;
+exports.describeExposed = federationBuilder.describeExposed;
+exports.describeSharedMappings = federationBuilder.describeSharedMappings;
+exports.federationBuilder = federationBuilder.federationBuilder;
+exports.getBuildAdapter = federationBuilder.getBuildAdapter;
+exports.getExternals = federationBuilder.getExternals;
+exports.loadFederationConfig = federationBuilder.loadFederationConfig;
+exports.logger = federationBuilder.logger;
+exports.lookupInResultMap = federationBuilder.lookupInResultMap;
+exports.setBuildAdapter = federationBuilder.setBuildAdapter;
+exports.setLogLevel = federationBuilder.setLogLevel;
+exports.writeFederationInfo = federationBuilder.writeFederationInfo;
+exports.writeImportMap = federationBuilder.writeImportMap;
+exports.DEFAULT_SECONARIES_SKIP_LIST = DEFAULT_SECONARIES_SKIP_LIST;
+exports._findSecondaries = _findSecondaries;
+exports.addSecondaries = addSecondaries;
+exports.findPackageJson = findPackageJson;
+exports.findRootTsConfigJson = findRootTsConfigJson;
+exports.findSecondaries = findSecondaries;
+exports.getDefaultEntry = getDefaultEntry;
+exports.getSecondaries = getSecondaries;
+exports.hashFile = hashFile;
+exports.inferProjectPath = inferProjectPath;
+exports.lookupVersion = lookupVersion;
+exports.lookupVersionInMap = lookupVersionInMap;
+exports.readConfiguredSecondaries = readConfiguredSecondaries;
+exports.setInferVersion = setInferVersion;
+exports.share = share;
+exports.shareAll = shareAll;
+exports.withFederation = withFederation;