@module-federation/esbuild 0.0.81 → 0.0.82

package/dist/build.mjs

@@ -0,0 +1,380 @@
+import path_0, { dirname, join } from "path";
+import fs_0, { existsSync, readFileSync } from "fs";
+import process from "process";
+import npmlog from "npmlog";
+import "json5";
+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;
+}
+async function loadFederationConfig(fedOptions) {
+    const fullConfigPath = join(fedOptions.workspaceRoot, fedOptions.federationConfig);
+    if (!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;
+}
+let _context = {};
+function getConfigContext() {
+    return _context;
+}
+const levels = npmlog.levels;
+npmlog.addLevel('error', levels.error, {
+    fg: 'brightWhite',
+    bg: 'red'
+}, ' ERR! ');
+npmlog.addLevel('warn', levels.info, {
+    fg: 'brightWhite',
+    bg: 'yellow'
+}, ' WARN ');
+npmlog.addLevel('info', levels.warn, {
+    fg: 'brightWhite',
+    bg: 'green'
+}, ' INFO ');
+npmlog.addLevel('notice', levels.notice, {
+    fg: 'black',
+    bg: 'brightYellow'
+}, ' NOTE ');
+npmlog.addLevel('verbose', levels.verbose, {
+    fg: 'brightWhite',
+    bg: 'brightBlue'
+}, ' VRB! ');
+npmlog.addLevel('silly', levels.silly, {
+    fg: 'black',
+    bg: 'white'
+}, ' DBG! ');
+const logger_logger = {
+    error: (msg)=>npmlog.error('', msg),
+    warn: (msg)=>npmlog.warn('', msg),
+    notice: (msg)=>npmlog.notice('', msg),
+    info: (msg)=>npmlog.info('', msg),
+    verbose: (msg)=>npmlog.verbose('', msg),
+    debug: (msg)=>npmlog.silly('', msg)
+};
+const setLogLevel = (level)=>{
+    npmlog.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)=>join(f, 'package.json')).filter((f)=>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(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(readFileSync(f, 'utf-8'));
+        const directory = normalize_normalize(dirname(f), true);
+        const result = {
+            content,
+            directory
+        };
+        return result;
+    });
+    packageCache[cacheKey] = maps;
+    return maps;
+}
+function findDepPackageJson(packageName, projectRoot) {
+    const mainPkgName = getPkgFolder(packageName);
+    let mainPkgPath = join(projectRoot, 'node_modules', mainPkgName);
+    let mainPkgJsonPath = join(mainPkgPath, 'package.json');
+    let directory = projectRoot;
+    while(dirname(directory) !== directory){
+        if (existsSync(mainPkgJsonPath)) break;
+        directory = normalize_normalize(dirname(directory), true);
+        mainPkgPath = join(directory, 'node_modules', mainPkgName);
+        mainPkgJsonPath = join(mainPkgPath, 'package.json');
+    }
+    if (!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(process.cwd());
+    const projectRoot = path_0.dirname(packageJson);
+    const tsConfigBaseJson = path_0.join(projectRoot, 'tsconfig.base.json');
+    const tsConfigJson = path_0.join(projectRoot, 'tsconfig.json');
+    if (fs_0.existsSync(tsConfigBaseJson)) return tsConfigBaseJson;
+    if (fs_0.existsSync(tsConfigJson)) return tsConfigJson;
+    throw new Error('Neither a tsconfig.json nor a tsconfig.base.json was found');
+}
+function findPackageJson(folder) {
+    while(!fs_0.existsSync(path_0.join(folder, 'package.json')) && path_0.dirname(folder) !== folder)folder = path_0.dirname(folder);
+    const filePath = path_0.join(folder, 'package.json');
+    if (fs_0.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 = fs_0.readdirSync(libPath);
+    const dirs = files.map((f)=>path_0.join(libPath, f)).filter((f)=>fs_0.lstatSync(f).isDirectory() && 'node_modules' !== f);
+    const secondaries = dirs.filter((d)=>fs_0.existsSync(path_0.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 (!fs_0.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 = path_0.join(libPath, 'package.json');
+    if (!fs_0.existsSync(libPackageJson)) return null;
+    const packageJson = JSON.parse(fs_0.readFileSync(libPackageJson, 'utf-8'));
+    const exports = packageJson['exports'];
+    if (!exports) return null;
+    const keys = Object.keys(exports).filter((key)=>'.' !== key && './package.json' !== key && !key.endsWith('*') && (exports[key]['default'] || 'string' == typeof exports[key]));
+    const result = {};
+    for (const key of keys){
+        const secondaryName = path_0.join(parent, key).replace(/\\/g, '/');
+        if (exclude.includes(secondaryName)) continue;
+        if (default_skip_list_isInSkipList(secondaryName, PREPARED_DEFAULT_SKIP_LIST)) continue;
+        const entry = getDefaultEntry(exports, 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(exports, key) {
+    let entry;
+    if ('string' == typeof exports[key]) entry = exports[key];
+    else {
+        var _exports_key;
+        entry = null == (_exports_key = exports[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 = path_0.dirname(getConfigContext().packageJson || '');
+    if (!projectPath && getConfigContext().workspaceRoot) projectPath = getConfigContext().workspaceRoot || '';
+    if (!projectPath) projectPath = process.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, path_0.dirname(packagePath));
+            if (!libPackageJson) {
+                logger_logger.error(`Could not find folder containing dep ${key}`);
+                continue;
+            }
+            const libPath = path_0.dirname(libPackageJson);
+            const secondaries = getSecondaries(includeSecondaries, libPath, key, shareObject);
+            if (secondaries) addSecondaries(secondaries, result);
+        }
+    }
+    return result;
+}
+function addSecondaries(secondaries, result) {
+    Object.assign(result, secondaries);
+}
+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;
+}
+export { DEFAULT_SECONARIES_SKIP_LIST, _findSecondaries, addSecondaries, findPackageJson, share_utils_findRootTsConfigJson as findRootTsConfigJson, findSecondaries, getDefaultEntry, getExternals, getSecondaries, loadFederationConfig, logger_logger as logger, lookupVersion, lookupVersionInMap, readConfiguredSecondaries, setInferVersion, setLogLevel, share, share_utils_shareAll as shareAll, withFederation };

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./src/index";
-export { default } from "./src/index";
+declare const _default: {};
+export default _default;

package/dist/index.js

@@ -0,0 +1,36 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__, {
+    default: ()=>__WEBPACK_DEFAULT_EXPORT__
+});
+const __WEBPACK_DEFAULT_EXPORT__ = {};
+exports["default"] = __webpack_exports__["default"];
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/index.mjs

@@ -0,0 +1,2 @@
+const src = {};
+export { src as default };