@module-federation/esbuild 0.0.81 → 0.0.83

package/dist/build.d.ts

@@ -1 +1,5 @@
-export * from "./src/build";
+export * from './lib/core/get-externals';
+export * from './lib/core/load-federation-config';
+export * from './lib/config/with-native-federation';
+export * from './lib/config/share-utils';
+export * from './lib/utils/logger';

package/dist/build.js

@@ -0,0 +1,481 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    shareAll: ()=>share_utils_shareAll,
+    setLogLevel: ()=>setLogLevel,
+    getExternals: ()=>getExternals,
+    addSecondaries: ()=>addSecondaries,
+    _findSecondaries: ()=>_findSecondaries,
+    findSecondaries: ()=>findSecondaries,
+    findPackageJson: ()=>findPackageJson,
+    getSecondaries: ()=>getSecondaries,
+    setInferVersion: ()=>setInferVersion,
+    share: ()=>share,
+    getDefaultEntry: ()=>getDefaultEntry,
+    logger: ()=>logger_logger,
+    DEFAULT_SECONARIES_SKIP_LIST: ()=>DEFAULT_SECONARIES_SKIP_LIST,
+    findRootTsConfigJson: ()=>share_utils_findRootTsConfigJson,
+    lookupVersionInMap: ()=>lookupVersionInMap,
+    lookupVersion: ()=>lookupVersion,
+    loadFederationConfig: ()=>loadFederationConfig,
+    readConfiguredSecondaries: ()=>readConfiguredSecondaries,
+    withFederation: ()=>withFederation
+});
+function getExternals(config) {
+    const shared = Object.keys(config.shared ?? {});
+    const remotes = config.remotes ?? {};
+    const remoteKeys = Object.keys(remotes).reduce((acc, key)=>{
+        if (!key) return acc;
+        acc.push(key);
+        acc.push(key + '/*');
+        return acc;
+    }, []);
+    const externals = [
+        ...shared,
+        ...remoteKeys
+    ];
+    return externals;
+}
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_fs_namespaceObject = require("fs");
+var external_fs_default = /*#__PURE__*/ __webpack_require__.n(external_fs_namespaceObject);
+async function loadFederationConfig(fedOptions) {
+    const fullConfigPath = external_path_namespaceObject.join(fedOptions.workspaceRoot, fedOptions.federationConfig);
+    if (!external_fs_namespaceObject.existsSync(fullConfigPath)) throw new Error('Expected ' + fullConfigPath);
+    const config = await import(`${fullConfigPath}`);
+    return config;
+}
+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/'),
+    (pkg)=>pkg.startsWith('@module-federation/')
+];
+const PREPARED_DEFAULT_SKIP_LIST = prepareSkipList(DEFAULT_SKIP_LIST);
+function prepareSkipList(skipList) {
+    return {
+        strings: new Set(skipList.filter((e)=>'string' == typeof e)),
+        functions: skipList.filter((e)=>'function' == typeof e),
+        regexps: skipList.filter((e)=>e instanceof RegExp)
+    };
+}
+function default_skip_list_isInSkipList(entry, skipList) {
+    if (skipList.strings.has(entry)) return true;
+    if (skipList.functions.some((f)=>f(entry))) return true;
+    if (skipList.regexps.some((r)=>r.test(entry))) return true;
+    return false;
+}
+const external_process_namespaceObject = require("process");
+var external_process_default = /*#__PURE__*/ __webpack_require__.n(external_process_namespaceObject);
+let _context = {};
+function getConfigContext() {
+    return _context;
+}
+const external_npmlog_namespaceObject = require("npmlog");
+var external_npmlog_default = /*#__PURE__*/ __webpack_require__.n(external_npmlog_namespaceObject);
+const levels = external_npmlog_default().levels;
+external_npmlog_default().addLevel('error', levels.error, {
+    fg: 'brightWhite',
+    bg: 'red'
+}, ' ERR! ');
+external_npmlog_default().addLevel('warn', levels.info, {
+    fg: 'brightWhite',
+    bg: 'yellow'
+}, ' WARN ');
+external_npmlog_default().addLevel('info', levels.warn, {
+    fg: 'brightWhite',
+    bg: 'green'
+}, ' INFO ');
+external_npmlog_default().addLevel('notice', levels.notice, {
+    fg: 'black',
+    bg: 'brightYellow'
+}, ' NOTE ');
+external_npmlog_default().addLevel('verbose', levels.verbose, {
+    fg: 'brightWhite',
+    bg: 'brightBlue'
+}, ' VRB! ');
+external_npmlog_default().addLevel('silly', levels.silly, {
+    fg: 'black',
+    bg: 'white'
+}, ' DBG! ');
+const logger_logger = {
+    error: (msg)=>external_npmlog_default().error('', msg),
+    warn: (msg)=>external_npmlog_default().warn('', msg),
+    notice: (msg)=>external_npmlog_default().notice('', msg),
+    info: (msg)=>external_npmlog_default().info('', msg),
+    verbose: (msg)=>external_npmlog_default().verbose('', msg),
+    debug: (msg)=>external_npmlog_default().silly('', msg)
+};
+const setLogLevel = (level)=>{
+    external_npmlog_default().level = 'debug' === level ? 'silly' : level;
+};
+setLogLevel('info');
+function normalize_normalize(path, trailingSlash) {
+    let cand = path.replace(/\\/g, '/');
+    if (void 0 === trailingSlash) return cand;
+    while(cand.endsWith('/'))cand = cand.substring(0, cand.length - 1);
+    if (trailingSlash) return cand + '/';
+    return cand;
+}
+const packageCache = {};
+function findPackageJsonFiles(project, workspace) {
+    return expandFolders(project, workspace).map((f)=>external_path_namespaceObject.join(f, 'package.json')).filter((f)=>external_fs_namespaceObject.existsSync(f));
+}
+function expandFolders(child, parent) {
+    const result = [];
+    parent = normalize_normalize(parent, true);
+    child = normalize_normalize(child, true);
+    if (!child.startsWith(parent)) throw new Error(`Workspace folder ${parent} needs to be a parent of the project folder ${child}`);
+    let current = child;
+    while(current !== parent){
+        result.push(current);
+        const cand = normalize_normalize(external_path_namespaceObject.dirname(current), true);
+        if (cand === current) break;
+        current = cand;
+    }
+    result.push(parent);
+    return result;
+}
+function getVersionMapCacheKey(project, workspace) {
+    return `${project}**${workspace}`;
+}
+function getVersionMaps(project, workspace) {
+    return getPackageJsonFiles(project, workspace).map((json)=>({
+            ...json.content['dependencies']
+        }));
+}
+function getPackageJsonFiles(project, workspace) {
+    const cacheKey = getVersionMapCacheKey(project, workspace);
+    let maps = packageCache[cacheKey];
+    if (maps) return maps;
+    maps = findPackageJsonFiles(project, workspace).map((f)=>{
+        const content = JSON.parse(external_fs_namespaceObject.readFileSync(f, 'utf-8'));
+        const directory = normalize_normalize(external_path_namespaceObject.dirname(f), true);
+        const result = {
+            content,
+            directory
+        };
+        return result;
+    });
+    packageCache[cacheKey] = maps;
+    return maps;
+}
+function findDepPackageJson(packageName, projectRoot) {
+    const mainPkgName = getPkgFolder(packageName);
+    let mainPkgPath = external_path_namespaceObject.join(projectRoot, 'node_modules', mainPkgName);
+    let mainPkgJsonPath = external_path_namespaceObject.join(mainPkgPath, 'package.json');
+    let directory = projectRoot;
+    while(external_path_namespaceObject.dirname(directory) !== directory){
+        if (external_fs_namespaceObject.existsSync(mainPkgJsonPath)) break;
+        directory = normalize_normalize(external_path_namespaceObject.dirname(directory), true);
+        mainPkgPath = external_path_namespaceObject.join(directory, 'node_modules', mainPkgName);
+        mainPkgJsonPath = external_path_namespaceObject.join(mainPkgPath, 'package.json');
+    }
+    if (!external_fs_namespaceObject.existsSync(mainPkgJsonPath)) {
+        logger_logger.verbose('No package.json found for ' + packageName + ' in ' + mainPkgPath);
+        return null;
+    }
+    return mainPkgJsonPath;
+}
+function getPkgFolder(packageName) {
+    const parts = packageName.split('/');
+    let folder = parts[0];
+    if (folder.startsWith('@')) folder += '/' + parts[1];
+    return folder;
+}
+let share_utils_inferVersion = false;
+const DEFAULT_SECONARIES_SKIP_LIST = [
+    '@angular/router/upgrade',
+    '@angular/common/upgrade'
+];
+function share_utils_findRootTsConfigJson() {
+    const packageJson = findPackageJson(external_process_default().cwd());
+    const projectRoot = external_path_default().dirname(packageJson);
+    const tsConfigBaseJson = external_path_default().join(projectRoot, 'tsconfig.base.json');
+    const tsConfigJson = external_path_default().join(projectRoot, 'tsconfig.json');
+    if (external_fs_default().existsSync(tsConfigBaseJson)) return tsConfigBaseJson;
+    if (external_fs_default().existsSync(tsConfigJson)) return tsConfigJson;
+    throw new Error('Neither a tsconfig.json nor a tsconfig.base.json was found');
+}
+function findPackageJson(folder) {
+    while(!external_fs_default().existsSync(external_path_default().join(folder, 'package.json')) && external_path_default().dirname(folder) !== folder)folder = external_path_default().dirname(folder);
+    const filePath = external_path_default().join(folder, 'package.json');
+    if (external_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('/');
+    key = parts.length >= 2 && parts[0].startsWith('@') ? `${parts[0]}/${parts[1]}` : parts[0];
+    if ('@angular-architects/module-federation-runtime' === key.toLowerCase()) key = '@angular-architects/module-federation';
+    return versions[key] || null;
+}
+function _findSecondaries(libPath, excludes, shareObject, acc) {
+    const files = external_fs_default().readdirSync(libPath);
+    const dirs = files.map((f)=>external_path_default().join(libPath, f)).filter((f)=>external_fs_default().lstatSync(f).isDirectory() && 'node_modules' !== f);
+    const secondaries = dirs.filter((d)=>external_fs_default().existsSync(external_path_default().join(d, 'package.json')));
+    for (const s of secondaries){
+        const secondaryLibName = s.replace(/\\/g, '/').replace(/^.*node_modules[/]/, '');
+        if (!excludes.includes(secondaryLibName)) {
+            if (!default_skip_list_isInSkipList(secondaryLibName, PREPARED_DEFAULT_SKIP_LIST)) {
+                acc[secondaryLibName] = {
+                    ...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 ('object' == typeof includeSecondaries) {
+        if (Array.isArray(includeSecondaries.skip)) exclude = includeSecondaries.skip;
+        else if ('string' == typeof includeSecondaries.skip) exclude = [
+            includeSecondaries.skip
+        ];
+    }
+    if (!external_fs_default().existsSync(libPath)) return {};
+    const configured = readConfiguredSecondaries(key, libPath, exclude, shareObject);
+    if (configured) return configured;
+    return findSecondaries(libPath, exclude, shareObject);
+}
+function readConfiguredSecondaries(parent, libPath, exclude, shareObject) {
+    const libPackageJson = external_path_default().join(libPath, 'package.json');
+    if (!external_fs_default().existsSync(libPackageJson)) return null;
+    const packageJson = JSON.parse(external_fs_default().readFileSync(libPackageJson, 'utf-8'));
+    const exports1 = packageJson['exports'];
+    if (!exports1) return null;
+    const keys = Object.keys(exports1).filter((key)=>'.' !== key && './package.json' !== key && !key.endsWith('*') && (exports1[key]['default'] || 'string' == typeof exports1[key]));
+    const result = {};
+    for (const key of keys){
+        const secondaryName = external_path_default().join(parent, key).replace(/\\/g, '/');
+        if (exclude.includes(secondaryName)) continue;
+        if (default_skip_list_isInSkipList(secondaryName, PREPARED_DEFAULT_SKIP_LIST)) continue;
+        const entry = getDefaultEntry(exports1, key);
+        if ('string' != typeof entry) {
+            console.log(`No entry point found for ${secondaryName}`);
+            continue;
+        }
+        if (![
+            '.css',
+            '.scss',
+            '.less'
+        ].some((ext)=>entry.endsWith(ext))) result[secondaryName] = {
+            ...shareObject
+        };
+    }
+    return result;
+}
+function getDefaultEntry(exports1, key) {
+    let entry;
+    if ('string' == typeof exports1[key]) entry = exports1[key];
+    else {
+        var _exports_key;
+        entry = null == (_exports_key = exports1[key]) ? void 0 : _exports_key['default'];
+        if ('object' == typeof entry) entry = entry['default'];
+    }
+    return entry;
+}
+function share_utils_shareAll(config, skip = DEFAULT_SKIP_LIST, projectPath = '') {
+    projectPath = inferProjectPath(projectPath);
+    const versionMaps = getVersionMaps(projectPath, projectPath);
+    const shareConfig = {};
+    for (const versions of versionMaps){
+        const preparedSkipList = prepareSkipList(skip);
+        for(const key in versions){
+            if (default_skip_list_isInSkipList(key, preparedSkipList)) continue;
+            const inferVersion = !config.requiredVersion || 'auto' === config.requiredVersion;
+            const requiredVersion = inferVersion ? versions[key] : config.requiredVersion;
+            if (!shareConfig[key]) shareConfig[key] = {
+                ...config,
+                requiredVersion
+            };
+        }
+    }
+    return share(share, projectPath);
+}
+function inferProjectPath(projectPath) {
+    if (!projectPath) projectPath = external_path_default().dirname(getConfigContext().packageJson || '');
+    if (!projectPath && getConfigContext().workspaceRoot) projectPath = getConfigContext().workspaceRoot || '';
+    if (!projectPath) projectPath = external_process_default().cwd();
+    return projectPath;
+}
+function setInferVersion(infer) {
+    share_utils_inferVersion = infer;
+}
+function share(shareObjects, projectPath = '') {
+    projectPath = inferProjectPath(projectPath);
+    const packagePath = findPackageJson(projectPath);
+    const result = {};
+    let includeSecondaries;
+    for(const key in shareObjects){
+        includeSecondaries = false;
+        const shareObject = shareObjects[key];
+        if ('auto' === shareObject.requiredVersion || share_utils_inferVersion && void 0 === shareObject.requiredVersion) {
+            const version = lookupVersion(key, projectPath);
+            shareObject.requiredVersion = version;
+            shareObject.version = version.replace(/^\D*/, '');
+        }
+        if (void 0 === shareObject.includeSecondaries) shareObject.includeSecondaries = true;
+        if (shareObject.includeSecondaries) {
+            includeSecondaries = shareObject.includeSecondaries;
+            delete shareObject.includeSecondaries;
+        }
+        result[key] = shareObject;
+        if (includeSecondaries) {
+            const libPackageJson = findDepPackageJson(key, external_path_default().dirname(packagePath));
+            if (!libPackageJson) {
+                logger_logger.error(`Could not find folder containing dep ${key}`);
+                continue;
+            }
+            const libPath = external_path_default().dirname(libPackageJson);
+            const secondaries = getSecondaries(includeSecondaries, libPath, key, shareObject);
+            if (secondaries) addSecondaries(secondaries, result);
+        }
+    }
+    return result;
+}
+function addSecondaries(secondaries, result) {
+    Object.assign(result, secondaries);
+}
+require("json5");
+function withFederation(config) {
+    const skip = prepareSkipList(config.skip ?? []);
+    return {
+        name: config.name ?? '',
+        filename: config.filename ?? 'remoteEntry',
+        exposes: config.exposes ?? {},
+        remotes: config.remotes ?? {},
+        shared: normalizeShared(config, skip)
+    };
+}
+function normalizeShared(config, skip) {
+    let result = {};
+    const shared = config.shared;
+    result = shared ? Object.keys(shared).reduce((acc, cur)=>({
+            ...acc,
+            [cur]: {
+                requiredVersion: shared[cur].requiredVersion ?? 'auto',
+                singleton: shared[cur].singleton ?? false,
+                strictVersion: shared[cur].strictVersion ?? false,
+                version: shared[cur].version,
+                includeSecondaries: shared[cur].includeSecondaries
+            }
+        }), {}) : share_utils_shareAll({
+        singleton: true,
+        strictVersion: true,
+        requiredVersion: 'auto'
+    });
+    result = Object.keys(result).filter((key)=>!default_skip_list_isInSkipList(key, skip)).reduce((acc, cur)=>({
+            ...acc,
+            [cur]: result[cur]
+        }), {});
+    return result;
+}
+exports.DEFAULT_SECONARIES_SKIP_LIST = __webpack_exports__.DEFAULT_SECONARIES_SKIP_LIST;
+exports._findSecondaries = __webpack_exports__._findSecondaries;
+exports.addSecondaries = __webpack_exports__.addSecondaries;
+exports.findPackageJson = __webpack_exports__.findPackageJson;
+exports.findRootTsConfigJson = __webpack_exports__.findRootTsConfigJson;
+exports.findSecondaries = __webpack_exports__.findSecondaries;
+exports.getDefaultEntry = __webpack_exports__.getDefaultEntry;
+exports.getExternals = __webpack_exports__.getExternals;
+exports.getSecondaries = __webpack_exports__.getSecondaries;
+exports.loadFederationConfig = __webpack_exports__.loadFederationConfig;
+exports.logger = __webpack_exports__.logger;
+exports.lookupVersion = __webpack_exports__.lookupVersion;
+exports.lookupVersionInMap = __webpack_exports__.lookupVersionInMap;
+exports.readConfiguredSecondaries = __webpack_exports__.readConfiguredSecondaries;
+exports.setInferVersion = __webpack_exports__.setInferVersion;
+exports.setLogLevel = __webpack_exports__.setLogLevel;
+exports.share = __webpack_exports__.share;
+exports.shareAll = __webpack_exports__.shareAll;
+exports.withFederation = __webpack_exports__.withFederation;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "DEFAULT_SECONARIES_SKIP_LIST",
+    "_findSecondaries",
+    "addSecondaries",
+    "findPackageJson",
+    "findRootTsConfigJson",
+    "findSecondaries",
+    "getDefaultEntry",
+    "getExternals",
+    "getSecondaries",
+    "loadFederationConfig",
+    "logger",
+    "lookupVersion",
+    "lookupVersionInMap",
+    "readConfiguredSecondaries",
+    "setInferVersion",
+    "setLogLevel",
+    "share",
+    "shareAll",
+    "withFederation"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});