@module-federation/esbuild 0.0.0-next-20240523224941

package/dist/build.esm.js

@@ -0,0 +1,389 @@
+import { g as getVersionMaps, a as getConfigContext, b as findDepPackageJson, l as logger } from './federation-builder.esm.js';
+export { j as buildForFederation, k as bundleExposedAndMappings, p as createBuildResultMap, i as defaultBuildParams, m as describeExposed, n as describeSharedMappings, f as federationBuilder, c as getBuildAdapter, e as getExternals, h as loadFederationConfig, l as logger, q as lookupInResultMap, s as setBuildAdapter, o as setLogLevel, d as writeFederationInfo, w as writeImportMap } from './federation-builder.esm.js';
+import * as path from 'path';
+import path__default from 'path';
+import * as fs from 'fs';
+import fs__default from 'fs';
+import process from 'process';
+import * as JSON5 from 'json5';
+import * as crypto from 'crypto';
+import 'npmlog';
+
+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.cwd());
+    const projectRoot = path__default.dirname(packageJson);
+    const tsConfigBaseJson = path__default.join(projectRoot, 'tsconfig.base.json');
+    const tsConfigJson = path__default.join(projectRoot, 'tsconfig.json');
+    if (fs__default.existsSync(tsConfigBaseJson)) {
+        return tsConfigBaseJson;
+    } else if (fs__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.existsSync(path__default.join(folder, 'package.json')) && path__default.dirname(folder) !== folder){
+        folder = path__default.dirname(folder);
+    }
+    const filePath = path__default.join(folder, 'package.json');
+    if (fs__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 = 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.readdirSync(libPath);
+    const dirs = files.map((f)=>path__default.join(libPath, f)).filter((f)=>fs__default.lstatSync(f).isDirectory() && f !== 'node_modules');
+    const secondaries = dirs.filter((d)=>fs__default.existsSync(path__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.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.join(libPath, 'package.json');
+    if (!fs__default.existsSync(libPackageJson)) {
+        return null;
+    }
+    const packageJson = JSON.parse(fs__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.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 = 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 && getConfigContext().packageJson) {
+        projectPath = path__default.dirname(getConfigContext().packageJson || '');
+    }
+    if (!projectPath && getConfigContext().workspaceRoot) {
+        projectPath = getConfigContext().workspaceRoot || '';
+    }
+    if (!projectPath) {
+        projectPath = process.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 = findDepPackageJson(key, path__default.dirname(packagePath));
+            if (!libPackageJson) {
+                logger.error('Could not find folder containing dep ' + key);
+                continue;
+            }
+            const libPath = path__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.isAbsolute(rootTsConfigPath)) {
+        throw new Error('SharedMappings.register: tsConfigPath needs to be an absolute path!');
+    }
+    if (!rootPath) {
+        rootPath = path.normalize(path.dirname(rootTsConfigPath));
+    }
+    const shareAll = !sharedMappings;
+    if (!sharedMappings) {
+        sharedMappings = [];
+    }
+    const tsConfig = JSON5.parse(fs.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.normalize(path.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('*'))) {
+        logger.warn('Sharing mapped paths with wildcards (*) not supported');
+    }
+    return result;
+}
+
+function hashFile(fileName) {
+    const fileBuffer = fs.readFileSync(fileName);
+    const hashSum = crypto.createHash('md5');
+    hashSum.update(fileBuffer);
+    return hashSum.digest('hex');
+}
+
+export { DEFAULT_SECONARIES_SKIP_LIST, _findSecondaries, addSecondaries, findPackageJson, findRootTsConfigJson, findSecondaries, getDefaultEntry, getSecondaries, hashFile, inferProjectPath, lookupVersion, lookupVersionInMap, readConfiguredSecondaries, setInferVersion, share, shareAll, withFederation };

package/dist/esbuild.cjs.d.ts

@@ -0,0 +1,2 @@
+export * from "./src/adapters/esbuild";
+export { default } from "./src/adapters/esbuild";