@module-federation/esbuild 0.0.95 → 0.0.97

package/dist/lib/utils/package-info.mjs

@@ -0,0 +1,265 @@
+import { existsSync, readFileSync } from "fs";
+import { dirname, join, relative } from "path";
+import { logger } from "./logger.mjs";
+import { normalize } from "./normalize.mjs";
+
+;// CONCATENATED MODULE: external "fs"
+
+;// CONCATENATED MODULE: external "path"
+
+;// CONCATENATED MODULE: external "./logger.mjs"
+
+;// CONCATENATED MODULE: external "./normalize.mjs"
+
+;// CONCATENATED MODULE: ./src/lib/utils/package-info.ts
+
+
+
+
+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(parent, true);
+    child = 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(dirname(current), true);
+        if (cand === current) {
+            break;
+        }
+        current = cand;
+    }
+    result.push(parent);
+    return result;
+}
+function getPackageInfo(packageName, workspaceRoot) {
+    workspaceRoot = normalize(workspaceRoot, true);
+    const packageJsonInfos = getPackageJsonFiles(workspaceRoot, workspaceRoot);
+    for (const info of packageJsonInfos){
+        const cand = _getPackageInfo(packageName, info.directory);
+        if (cand) {
+            return cand;
+        }
+    }
+    logger.warn('No meta data found for shared lib ' + packageName);
+    return null;
+}
+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(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(dirname(directory), true);
+        mainPkgPath = join(directory, 'node_modules', mainPkgName);
+        mainPkgJsonPath = join(mainPkgPath, 'package.json');
+    }
+    if (!existsSync(mainPkgJsonPath)) {
+        logger.verbose('No package.json found for ' + packageName + ' in ' + mainPkgPath);
+        return null;
+    }
+    return mainPkgJsonPath;
+}
+function _getPackageInfo(packageName, directory) {
+    var _mainPkgJson_exports, _mainPkgJson_exports_relSecondaryPath, _mainPkgJson_exports1, _mainPkgJson_exports_relSecondaryPath1, _mainPkgJson_exports2, _mainPkgJson_exports_relSecondaryPath2, _mainPkgJson_exports3;
+    const mainPkgName = getPkgFolder(packageName);
+    const mainPkgJsonPath = findDepPackageJson(packageName, directory);
+    if (!mainPkgJsonPath) {
+        return null;
+    }
+    const mainPkgPath = dirname(mainPkgJsonPath);
+    const mainPkgJson = readJson(mainPkgJsonPath);
+    const version = mainPkgJson['version'];
+    const esm = mainPkgJson['type'] === 'module';
+    if (!version) {
+        logger.warn('No version found for ' + packageName);
+        return null;
+    }
+    let relSecondaryPath = relative(mainPkgName, packageName);
+    if (!relSecondaryPath) {
+        relSecondaryPath = '.';
+    } else {
+        relSecondaryPath = './' + relSecondaryPath.replace(/\\/g, '/');
+    }
+    let cand = mainPkgJson === null || mainPkgJson === void 0 ? void 0 : (_mainPkgJson_exports = mainPkgJson.exports) === null || _mainPkgJson_exports === void 0 ? void 0 : _mainPkgJson_exports[relSecondaryPath];
+    if (typeof cand === 'string') {
+        return {
+            entryPoint: join(mainPkgPath, cand),
+            packageName,
+            version,
+            esm
+        };
+    }
+    cand = mainPkgJson === null || mainPkgJson === void 0 ? void 0 : (_mainPkgJson_exports1 = mainPkgJson.exports) === null || _mainPkgJson_exports1 === void 0 ? void 0 : (_mainPkgJson_exports_relSecondaryPath = _mainPkgJson_exports1[relSecondaryPath]) === null || _mainPkgJson_exports_relSecondaryPath === void 0 ? void 0 : _mainPkgJson_exports_relSecondaryPath.import;
+    if (typeof cand === 'object') {
+        if (cand.module) {
+            cand = cand.module;
+        } else if (cand.import) {
+            cand = cand.import;
+        } else if (cand.default) {
+            cand = cand.default;
+        } else {
+            cand = null;
+        }
+    }
+    if (cand) {
+        if (typeof cand === 'object') {
+            if (cand.module) {
+                cand = cand.module;
+            } else if (cand.import) {
+                cand = cand.import;
+            } else if (cand.default) {
+                cand = cand.default;
+            } else {
+                cand = null;
+            }
+        }
+        return {
+            entryPoint: join(mainPkgPath, cand),
+            packageName,
+            version,
+            esm
+        };
+    }
+    cand = mainPkgJson === null || mainPkgJson === void 0 ? void 0 : (_mainPkgJson_exports2 = mainPkgJson.exports) === null || _mainPkgJson_exports2 === void 0 ? void 0 : (_mainPkgJson_exports_relSecondaryPath1 = _mainPkgJson_exports2[relSecondaryPath]) === null || _mainPkgJson_exports_relSecondaryPath1 === void 0 ? void 0 : _mainPkgJson_exports_relSecondaryPath1.module;
+    if (typeof cand === 'object') {
+        if (cand.module) {
+            cand = cand.module;
+        } else if (cand.import) {
+            cand = cand.import;
+        } else if (cand.default) {
+            cand = cand.default;
+        } else {
+            cand = null;
+        }
+    }
+    if (cand) {
+        return {
+            entryPoint: join(mainPkgPath, cand),
+            packageName,
+            version,
+            esm
+        };
+    }
+    cand = mainPkgJson === null || mainPkgJson === void 0 ? void 0 : (_mainPkgJson_exports3 = mainPkgJson.exports) === null || _mainPkgJson_exports3 === void 0 ? void 0 : (_mainPkgJson_exports_relSecondaryPath2 = _mainPkgJson_exports3[relSecondaryPath]) === null || _mainPkgJson_exports_relSecondaryPath2 === void 0 ? void 0 : _mainPkgJson_exports_relSecondaryPath2.default;
+    if (cand) {
+        if (typeof cand === 'object') {
+            if (cand.module) {
+                cand = cand.module;
+            } else if (cand.import) {
+                cand = cand.import;
+            } else if (cand.default) {
+                cand = cand.default;
+            } else {
+                cand = null;
+            }
+        }
+        return {
+            entryPoint: join(mainPkgPath, cand),
+            packageName,
+            version,
+            esm
+        };
+    }
+    cand = mainPkgJson['module'];
+    if (cand && relSecondaryPath === '.') {
+        return {
+            entryPoint: join(mainPkgPath, cand),
+            packageName,
+            version,
+            esm: true
+        };
+    }
+    const secondaryPgkPath = join(mainPkgPath, relSecondaryPath);
+    const secondaryPgkJsonPath = join(secondaryPgkPath, 'package.json');
+    let secondaryPgkJson = null;
+    if (existsSync(secondaryPgkJsonPath)) {
+        secondaryPgkJson = readJson(secondaryPgkJsonPath);
+    }
+    if (secondaryPgkJson && secondaryPgkJson.module) {
+        return {
+            entryPoint: join(secondaryPgkPath, secondaryPgkJson.module),
+            packageName,
+            version,
+            esm: true
+        };
+    }
+    cand = join(secondaryPgkPath, 'index.mjs');
+    if (existsSync(cand)) {
+        return {
+            entryPoint: cand,
+            packageName,
+            version,
+            esm: true
+        };
+    }
+    if (secondaryPgkJson && secondaryPgkJson.main) {
+        return {
+            entryPoint: join(secondaryPgkPath, secondaryPgkJson.main),
+            packageName,
+            version,
+            esm
+        };
+    }
+    cand = join(secondaryPgkPath, 'index.js');
+    if (existsSync(cand)) {
+        return {
+            entryPoint: cand,
+            packageName,
+            version,
+            esm
+        };
+    }
+    logger.warn('No entry point found for ' + packageName);
+    logger.warn("If you don't need this package, skip it in your federation.config.js or consider moving it into depDependencies in your package.json");
+    return null;
+}
+function readJson(mainPkgJsonPath) {
+    return JSON.parse(readFileSync(mainPkgJsonPath, 'utf-8'));
+}
+function getPkgFolder(packageName) {
+    const parts = packageName.split('/');
+    let folder = parts[0];
+    if (folder.startsWith('@')) {
+        folder += '/' + parts[1];
+    }
+    return folder;
+}
+
+export { _getPackageInfo, expandFolders, findDepPackageJson, findPackageJsonFiles, getPackageInfo, getPackageJsonFiles, getVersionMaps };

package/dist/plugin.d.ts

@@ -0,0 +1 @@
+export * from './adapters/lib/plugin';