@softarc/native-federation 3.5.5 → 4.0.0-RC10

package/src/lib/utils/cache-persistence.js

@@ -0,0 +1,66 @@
+import path from 'path';
+import fs from 'fs';
+import crypto from 'crypto';
+import { logger } from './logger.js';
+export const getDefaultCachePath = (workspaceRoot) => path.join(workspaceRoot, 'node_modules/.cache/native-federation');
+export const getFilename = (title, dev) => {
+    const devSuffix = dev ? '-dev' : '';
+    return `${title}${devSuffix}.meta.json`;
+};
+export const getChecksum = (shared, dev) => {
+    const denseExternals = Object.keys(shared)
+        .sort()
+        .reduce((clean, external) => {
+        return (clean + ':' + external + (shared[external].version ? `@${shared[external].version}` : ''));
+    }, 'deps');
+    return crypto
+        .createHash('sha256')
+        .update(denseExternals + `:dev=${dev}`)
+        .digest('hex');
+};
+export const cacheEntry = (pathToCache, fileName) => ({
+    getMetadata: (checksum) => {
+        const metadataFile = path.join(pathToCache, fileName);
+        if (!fs.existsSync(pathToCache) || !fs.existsSync(metadataFile))
+            return undefined;
+        const cachedResult = JSON.parse(fs.readFileSync(metadataFile, 'utf-8'));
+        if (cachedResult.checksum !== checksum)
+            return undefined;
+        return cachedResult;
+    },
+    persist: (payload) => {
+        fs.writeFileSync(path.join(pathToCache, fileName), JSON.stringify(payload), 'utf-8');
+    },
+    copyFiles: (fullOutputPath) => {
+        const metadataFile = path.join(pathToCache, fileName);
+        if (!fs.existsSync(metadataFile))
+            throw new Error('Error copying artifacts to dist, metadata file could not be found.');
+        const cachedResult = JSON.parse(fs.readFileSync(metadataFile, 'utf-8'));
+        fs.mkdirSync(path.dirname(fullOutputPath), { recursive: true });
+        cachedResult.files.forEach(file => {
+            const cachedFile = path.join(pathToCache, file);
+            const distFileName = path.join(fullOutputPath, file);
+            if (fs.existsSync(cachedFile)) {
+                fs.copyFileSync(cachedFile, distFileName);
+            }
+        });
+    },
+    clear: () => {
+        const metadataFile = path.join(pathToCache, fileName);
+        if (!fs.existsSync(pathToCache)) {
+            fs.mkdirSync(pathToCache, { recursive: true });
+            logger.debug(`Creating cache folder '${pathToCache}' for '${fileName}'.`);
+            return;
+        }
+        if (!fs.existsSync(metadataFile))
+            return;
+        logger.debug(`Purging cached bundle '${metadataFile}'.`);
+        const cachedResult = JSON.parse(fs.readFileSync(metadataFile, 'utf-8'));
+        cachedResult.files.forEach(file => {
+            const cachedFile = path.join(pathToCache, file);
+            if (fs.existsSync(cachedFile))
+                fs.unlinkSync(cachedFile);
+        });
+        fs.unlinkSync(metadataFile);
+    },
+});

package/src/lib/utils/errors.js

@@ -1,12 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbortedError = void 0;
-class AbortedError extends Error {
+export class AbortedError extends Error {
     constructor(message) {
         super(message);
         this.name = 'AbortedError';
         Object.setPrototypeOf(this, AbortedError.prototype);
     }
 }
-exports.AbortedError = AbortedError;
-//# sourceMappingURL=errors.js.map

package/src/lib/utils/get-external-imports.js

@@ -1,11 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getExternalImports = getExternalImports;
-const tslib_1 = require("tslib");
-const path = tslib_1.__importStar(require("path"));
-const fs = tslib_1.__importStar(require("fs"));
-const ts = tslib_1.__importStar(require("typescript"));
-function getExternalImports(entryFilePath) {
+import * as path from 'path';
+import * as fs from 'fs';
+import * as ts from 'typescript';
+export function getExternalImports(entryFilePath) {
     const visited = new Set();
     const externals = new Set();
     function isExternal(specifier) {
@@ -25,7 +21,7 @@ function getExternalImports(entryFilePath) {
             }
         }
         if (fs.existsSync(abs) && fs.statSync(abs).isDirectory()) {
-            for (const file of extensions.map((e) => 'index' + e)) {
+            for (const file of extensions.map(e => 'index' + e)) {
                 const indexPath = path.join(abs, file);
                 if (fs.existsSync(indexPath) && fs.statSync(indexPath).isFile()) {
                     return indexPath;
@@ -82,4 +78,3 @@ function getExternalImports(entryFilePath) {
     visit(entryFilePath);
     return Array.from(externals);
 }
-//# sourceMappingURL=get-external-imports.js.map

package/src/lib/utils/get-used-dependencies.d.ts

@@ -0,0 +1,7 @@
+import { type PathToImport } from '../domain/utils/mapped-path.contract.js';
+import { type UsedDependencies } from '../domain/utils/used-dependencies.contract.js';
+export declare function getUsedDependenciesFactory(workspaceRoot: string, fallbackEntryPoints?: string[]): (config: {
+    name?: string;
+    exposes?: Record<string, string>;
+    sharedMappings: PathToImport;
+}) => UsedDependencies;

package/src/lib/utils/get-used-dependencies.js

@@ -0,0 +1,123 @@
+import { getProjectData } from '@softarc/sheriff-core';
+import { cwd } from 'process';
+import { getPackageInfo } from './package-info.js';
+import { getExternalImports as extractExternalImports } from './get-external-imports.js';
+import * as path from 'path';
+export function getUsedDependenciesFactory(workspaceRoot, fallbackEntryPoints) {
+    return config => {
+        let entryPoints = Object.values(config.exposes ?? {});
+        if (entryPoints.length < 1)
+            entryPoints = fallbackEntryPoints;
+        if (!entryPoints || entryPoints.length < 1)
+            throw new Error('[removeUnusedDeps] native-federation is missing an entryPoint! You can set it using the Federation options or by setting an exposed module in the Federation config file.');
+        const fileInfos = Object.values(entryPoints ?? []).reduce((acc, entryPoint) => ({
+            ...acc,
+            ...getProjectData(entryPoint, cwd(), {
+                includeExternalLibraries: true,
+            }),
+        }), {});
+        const usedPackageNames = new Set();
+        for (const fileInfo of Object.values(fileInfos)) {
+            for (const pckg of [
+                ...(fileInfo?.externalLibraries || []),
+                ...(fileInfo?.unresolvedImports || []),
+            ]) {
+                usedPackageNames.add(pckg);
+            }
+        }
+        return {
+            external: addTransientDeps(usedPackageNames, workspaceRoot),
+            internal: resolveUsedMappings(fileInfos, workspaceRoot, config.sharedMappings),
+        };
+    };
+}
+function addTransientDeps(packages, workspaceRoot) {
+    const packagesAndPeers = new Set([...packages]);
+    const discovered = new Set(packagesAndPeers);
+    const stack = [...packagesAndPeers];
+    while (stack.length > 0) {
+        const dep = stack.pop();
+        if (!dep) {
+            continue;
+        }
+        const pInfo = getPackageInfo(dep, workspaceRoot);
+        if (!pInfo) {
+            continue;
+        }
+        const peerDeps = extractExternalImports(pInfo.entryPoint);
+        for (const peerDep of peerDeps) {
+            if (!discovered.has(peerDep)) {
+                discovered.add(peerDep);
+                stack.push(peerDep);
+                packagesAndPeers.add(peerDep);
+            }
+        }
+    }
+    return packagesAndPeers;
+}
+function resolveUsedMappings(fileInfos, workspaceRoot, sharedMappings) {
+    const usedMappings = {};
+    for (const fileName of Object.keys(fileInfos)) {
+        const fullFileName = path.join(workspaceRoot, fileName);
+        if (isSharedMapping(fullFileName, sharedMappings))
+            continue;
+        const fileInfo = fileInfos[fileName];
+        if (!fileInfo)
+            continue;
+        // Check if any of this file's imports land in a shared mapping
+        for (const imp of fileInfo.imports ?? []) {
+            const fullImport = path.join(workspaceRoot, imp);
+            const match = matchMapping(fullImport, sharedMappings);
+            if (match)
+                usedMappings[fullImport] = match;
+        }
+    }
+    return usedMappings;
+}
+function isSharedMapping(filePath, sharedMappings) {
+    for (const sharedPath of Object.keys(sharedMappings)) {
+        const asteriskIndex = sharedPath.indexOf('*');
+        if (asteriskIndex !== -1) {
+            const prefix = sharedPath.substring(0, asteriskIndex);
+            if (filePath.startsWith(prefix))
+                return true;
+        }
+        else if (filePath.startsWith(sharedPath + path.sep) || filePath === sharedPath) {
+            return true;
+        }
+    }
+    return false;
+}
+function matchMapping(filePath, sharedMappings) {
+    for (const [sharedPath, sharedImport] of Object.entries(sharedMappings)) {
+        const asteriskIndex = sharedPath.indexOf('*');
+        if (asteriskIndex !== -1) {
+            const prefix = sharedPath.substring(0, asteriskIndex);
+            const suffix = sharedPath.substring(asteriskIndex + 1);
+            if (!filePath.startsWith(prefix))
+                continue;
+            if (suffix && !filePath.includes(suffix))
+                continue;
+            const captured = suffix
+                ? filePath.slice(prefix.length, filePath.indexOf(suffix, prefix.length))
+                : filePath.slice(prefix.length);
+            return sharedImport.replace('*', toImportPath(captured));
+        }
+        else if (filePath === sharedPath || isIndexOf(filePath, sharedPath)) {
+            return sharedImport;
+        }
+    }
+    return null;
+}
+/**
+ * Detect if it's a barrel file which is inferred by typescript
+ */
+const INDEX_PATTERN = /\/index\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/;
+function isIndexOf(filePath, dirPath) {
+    return filePath.startsWith(dirPath + path.sep) && INDEX_PATTERN.test(filePath);
+}
+function toImportPath(filePath) {
+    const withoutExt = filePath.replace(/\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/, '');
+    const normalized = withoutExt.replace(/\\/g, '/');
+    return normalized.endsWith('/index') ? normalized.slice(0, -6) : normalized;
+}

package/src/lib/utils/hash-file.js

@@ -1,13 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hashFile = hashFile;
-const tslib_1 = require("tslib");
-const crypto = tslib_1.__importStar(require("crypto"));
-const fs = tslib_1.__importStar(require("fs"));
-function hashFile(fileName) {
+import * as crypto from 'crypto';
+import * as fs from 'fs';
+export function hashFile(fileName) {
     const fileBuffer = fs.readFileSync(fileName);
     const hashSum = crypto.createHash('md5');
     hashSum.update(fileBuffer);
     return hashSum.digest('hex');
 }
-//# sourceMappingURL=hash-file.js.map

package/src/lib/utils/logger.js

@@ -1,17 +1,13 @@
-"use strict";
 /* eslint-disable @typescript-eslint/no-explicit-any */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.setLogLevel = exports.logger = void 0;
-const tslib_1 = require("tslib");
-const chalk_1 = tslib_1.__importDefault(require("chalk"));
+import chalk from 'chalk';
 let verbose = false;
-exports.logger = {
-    warn: (msg) => console.warn(chalk_1.default.bgYellow.ansi256(15)(' WARN '), msg),
-    error: (msg) => console.error(chalk_1.default.bgRed.ansi256(15)(' ERRR '), msg),
-    notice: (msg) => console.log(chalk_1.default.bgYellowBright.black(' NOTE '), msg),
-    info: (msg) => console.log(chalk_1.default.bgGreen.ansi256(15)(' INFO '), msg),
-    verbose: (msg) => verbose && console.log(chalk_1.default.bgGreen.ansi256(15)(' DBG! '), msg),
-    debug: (msg) => verbose && console.log(chalk_1.default.bgGreen.ansi256(15)(' DBG! '), msg),
+export const logger = {
+    warn: (msg) => console.warn(chalk.bgYellow.ansi256(15)(' WARN '), msg),
+    error: (msg) => console.error(chalk.bgRed.ansi256(15)(' ERRR '), msg),
+    notice: (msg) => console.log(chalk.bgYellowBright.black(' NOTE '), msg),
+    info: (msg) => console.log(chalk.bgGreen.ansi256(15)(' INFO '), msg),
+    verbose: (msg) => verbose && console.log(chalk.bgGreen.ansi256(15)(' DBG! '), msg),
+    debug: (msg) => verbose && console.log(chalk.bgGreen.ansi256(15)(' DBG! '), msg),
     measure: (start, milestone) => {
         if (!verbose)
             return;
@@ -23,11 +19,9 @@ exports.logger = {
         const timeStr = `${minutes.toString().padStart(2, '0')}:${seconds
             .toString()
             .padStart(2, '0')}:${msFormatted.padStart(7, '0')}ms`;
-        console.log(chalk_1.default.bgGreen.ansi256(15)(' DBG! '), `${timeStr} - ${milestone}`);
+        console.log(chalk.bgGreen.ansi256(15)(' DBG! '), `${timeStr} - ${milestone}`);
     },
 };
-const setLogLevel = (level) => {
+export const setLogLevel = (level) => {
     verbose = level === 'verbose';
 };
-exports.setLogLevel = setLogLevel;
-//# sourceMappingURL=logger.js.map

package/src/lib/utils/mapped-paths.d.ts

@@ -1,10 +1,7 @@
-export interface MappedPath {
-    key: string;
-    path: string;
-}
-export interface GetMappedPathsOptions {
-    rootTsConfigPath: string;
-    sharedMappings?: string[];
-    rootPath?: string;
-}
-export declare function getMappedPaths({ rootTsConfigPath, sharedMappings, rootPath, }: GetMappedPathsOptions): Array<MappedPath>;
+import type { PathToImport } from '../domain/utils/mapped-path.contract.js';
+/**
+ * Will return user defined and tsconfig defined paths including their imports, might contain wildcards
+ * @param param0
+ * @returns
+ */
+export declare function getRawMappedPaths(rootTsConfigPath: string, configuredSharedMappings?: string[], rootPath?: string): PathToImport;

package/src/lib/utils/mapped-paths.js

@@ -1,52 +1,33 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMappedPaths = getMappedPaths;
-const tslib_1 = require("tslib");
-const path = tslib_1.__importStar(require("path"));
-const fs = tslib_1.__importStar(require("fs"));
-const JSON5 = tslib_1.__importStar(require("json5"));
-const logger_1 = require("../utils/logger");
-const resolve_wildcard_keys_1 = require("./resolve-wildcard-keys");
-function getMappedPaths({ rootTsConfigPath, sharedMappings, rootPath, }) {
-    const result = [];
+import * as path from 'path';
+import * as fs from 'fs';
+import JSON5 from 'json5';
+/**
+ * Will return user defined and tsconfig defined paths including their imports, might contain wildcards
+ * @param param0
+ * @returns
+ */
+export function getRawMappedPaths(rootTsConfigPath, configuredSharedMappings, rootPath) {
+    const mappedPaths = {};
     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 shareAllMappings = !sharedMappings;
-    if (!sharedMappings) {
-        sharedMappings = [];
+    const shareAll = !configuredSharedMappings;
+    if (!configuredSharedMappings) {
+        configuredSharedMappings = [];
     }
-    const globSharedMappings = sharedMappings
-        .filter((m) => m.endsWith('*'))
-        .map((m) => m.slice(0, -1));
     const tsConfig = JSON5.parse(fs.readFileSync(rootTsConfigPath, { encoding: 'utf-8' }));
     const mappings = tsConfig?.compilerOptions?.paths;
     if (!mappings) {
-        return result;
+        return mappedPaths;
     }
     for (const key in mappings) {
-        if (mappings[key].length > 1) {
-            logger_1.logger.warn('[shared-mapping][' +
-                key +
-                '] A mapping path with more than 1 entryPoint is currently not supported, falling back to the first path.');
+        const libPath = path.normalize(path.join(rootPath, mappings[key][0]));
+        if (configuredSharedMappings.includes(key) || shareAll) {
+            mappedPaths[libPath] = key;
         }
-        const libPaths = key.includes('*')
-            ? (0, resolve_wildcard_keys_1.resolveTsConfigWildcard)(key, mappings[key][0], rootPath).map(({ key, value }) => ({
-                key,
-                path: path.normalize(path.join(rootPath, value)),
-            }))
-            : [{ key, path: path.normalize(path.join(rootPath, mappings[key][0])) }];
-        libPaths
-            .filter((mapping) => shareAllMappings ||
-            sharedMappings.includes(mapping.key) ||
-            globSharedMappings.some((m) => mapping.key.startsWith(m)))
-            .forEach((mapping) => {
-            result.push(mapping);
-        });
     }
-    return result;
+    return mappedPaths;
 }
-//# sourceMappingURL=mapped-paths.js.map

package/src/lib/utils/normalize.js

@@ -1,8 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalize = normalize;
-exports.normalizePackageName = normalizePackageName;
-function normalize(path, trailingSlash) {
+export function normalize(path, trailingSlash) {
     let cand = path.replace(/\\/g, '/');
     if (typeof trailingSlash === 'undefined') {
         return cand;
@@ -15,8 +11,7 @@ function normalize(path, trailingSlash) {
     }
     return cand;
 }
-function normalizePackageName(fileName) {
+export function normalizePackageName(fileName) {
     const sanitized = fileName.replace(/[^A-Za-z0-9]/g, '_');
     return sanitized.startsWith('_') ? sanitized.slice(1) : sanitized;
 }
-//# sourceMappingURL=normalize.js.map

package/src/lib/utils/package-info.js

@@ -1,19 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isESMExport = void 0;
-exports.findPackageJsonFiles = findPackageJsonFiles;
-exports.expandFolders = expandFolders;
-exports.getPackageInfo = getPackageInfo;
-exports.getVersionMaps = getVersionMaps;
-exports.getPackageJsonFiles = getPackageJsonFiles;
-exports.findDepPackageJson = findDepPackageJson;
-exports._getPackageInfo = _getPackageInfo;
-const tslib_1 = require("tslib");
-const fs = tslib_1.__importStar(require("fs"));
-const path = tslib_1.__importStar(require("path"));
-const logger_1 = require("./logger");
-const normalize_1 = require("./normalize");
-const isESMExport = (e) => {
+import * as fs from 'fs';
+import * as path from 'path';
+import { logger } from './logger.js';
+import { normalize } from './normalize.js';
+export const isESMExport = (e) => {
     if (e === 'import' || e === 'module-sync')
         return true;
     // Common ESM conventions
@@ -27,24 +16,23 @@ const isESMExport = (e) => {
     // Ambiguous
     return undefined;
 };
-exports.isESMExport = isESMExport;
 const packageCache = {};
-function findPackageJsonFiles(project, workspace) {
+export function findPackageJsonFiles(project, workspace) {
     return expandFolders(project, workspace)
-        .map((f) => path.join(f, 'package.json'))
-        .filter((f) => fs.existsSync(f));
+        .map(f => path.join(f, 'package.json'))
+        .filter(f => fs.existsSync(f));
 }
-function expandFolders(child, parent) {
+export function expandFolders(child, parent) {
     const result = [];
-    parent = (0, normalize_1.normalize)(parent, true);
-    child = (0, normalize_1.normalize)(child, true);
+    parent = normalize(parent, true);
+    child = normalize(child, true);
     if (!child.startsWith(parent)) {
         throw new Error(`Workspace folder ${path} needs to be a parent of the project folder ${child}`);
     }
     let current = child;
     while (current !== parent) {
         result.push(current);
-        const cand = (0, normalize_1.normalize)(path.dirname(current), true);
+        const cand = normalize(path.dirname(current), true);
         if (cand === current) {
             break;
         }
@@ -53,8 +41,8 @@ function expandFolders(child, parent) {
     result.push(parent);
     return result;
 }
-function getPackageInfo(packageName, workspaceRoot) {
-    workspaceRoot = (0, normalize_1.normalize)(workspaceRoot, true);
+export function getPackageInfo(packageName, workspaceRoot) {
+    workspaceRoot = normalize(workspaceRoot, true);
     const packageJsonInfos = getPackageJsonFiles(workspaceRoot, workspaceRoot);
     for (const info of packageJsonInfos) {
         const cand = _getPackageInfo(packageName, info.directory);
@@ -62,26 +50,26 @@ function getPackageInfo(packageName, workspaceRoot) {
             return cand;
         }
     }
-    logger_1.logger.warn('No meta data found for shared lib ' + packageName);
+    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) => ({
+export function getVersionMaps(project, workspace) {
+    return getPackageJsonFiles(project, workspace).map(json => ({
         ...json.content['dependencies'],
     }));
 }
-function getPackageJsonFiles(project, workspace) {
+export function getPackageJsonFiles(project, workspace) {
     const cacheKey = getVersionMapCacheKey(project, workspace);
     let maps = packageCache[cacheKey];
     if (maps) {
         return maps;
     }
-    maps = findPackageJsonFiles(project, workspace).map((f) => {
+    maps = findPackageJsonFiles(project, workspace).map(f => {
         const content = JSON.parse(fs.readFileSync(f, 'utf-8'));
-        const directory = (0, normalize_1.normalize)(path.dirname(f), true);
+        const directory = normalize(path.dirname(f), true);
         const result = {
             content,
             directory,
@@ -91,8 +79,10 @@ function getPackageJsonFiles(project, workspace) {
     packageCache[cacheKey] = maps;
     return maps;
 }
-function findDepPackageJson(packageName, projectRoot) {
+export function findDepPackageJson(packageName, projectRoot) {
     const mainPkgName = getPkgFolder(packageName);
+    if (!mainPkgName)
+        throw new Error(`Package.json "${packageName}" is missing`);
     let mainPkgPath = path.join(projectRoot, 'node_modules', mainPkgName);
     let mainPkgJsonPath = path.join(mainPkgPath, 'package.json');
     let directory = projectRoot;
@@ -100,14 +90,14 @@ function findDepPackageJson(packageName, projectRoot) {
         if (fs.existsSync(mainPkgJsonPath)) {
             break;
         }
-        directory = (0, normalize_1.normalize)(path.dirname(directory), true);
+        directory = normalize(path.dirname(directory), true);
         mainPkgPath = path.join(directory, 'node_modules', mainPkgName);
         mainPkgJsonPath = path.join(mainPkgPath, 'package.json');
     }
     if (!fs.existsSync(mainPkgJsonPath)) {
         // TODO: Add logger
         // context.logger.warn('No package.json found for ' + packageName);
-        logger_1.logger.verbose('No package.json found for ' + packageName + ' in ' + mainPkgPath);
+        logger.verbose('No package.json found for ' + packageName + ' in ' + mainPkgPath);
         return null;
     }
     return mainPkgJsonPath;
@@ -137,7 +127,7 @@ function findOptimalExport(target, info, isESM = undefined) {
     const exportTypes = Object.keys(target);
     // We prefer ESM exports for native support.
     if (typeof isESM === 'undefined') {
-        const esmExport = exportTypes.find((e) => (0, exports.isESMExport)(e));
+        const esmExport = exportTypes.find(e => isESMExport(e));
         if (esmExport) {
             return findOptimalExport(target[esmExport], info, true);
         }
@@ -145,12 +135,14 @@ function findOptimalExport(target, info, isESM = undefined) {
     // Node.js looks at the exports object and uses the first key that matches the current environment.
     const secondBestEntry = 'default' in target && target['default']
         ? 'default'
-        : exportTypes.filter((e) => e !== 'types')[0];
+        : exportTypes.filter(e => e !== 'types')[0];
     const secondBestExport = target[secondBestEntry];
-    return findOptimalExport(secondBestExport, info, isESM ?? (0, exports.isESMExport)(secondBestEntry));
+    return findOptimalExport(secondBestExport, info, isESM ?? isESMExport(secondBestEntry));
 }
-function _getPackageInfo(packageName, directory) {
+export function _getPackageInfo(packageName, directory) {
     const mainPkgName = getPkgFolder(packageName);
+    if (!mainPkgName)
+        throw new Error(`Could not resolve "${packageName}" in "${directory}`);
     const mainPkgJsonPath = findDepPackageJson(packageName, directory);
     if (!mainPkgJsonPath) {
         return null;
@@ -160,15 +152,13 @@ function _getPackageInfo(packageName, directory) {
     const version = mainPkgJson['version'];
     const esm = mainPkgJson['type'] === 'module';
     if (!version) {
-        logger_1.logger.warn('No version found for ' + packageName);
+        logger.warn('No version found for ' + packageName);
         return null;
     }
     const pathToSecondary = path.relative(mainPkgName, packageName);
-    const relSecondaryPath = !pathToSecondary
-        ? '.'
-        : './' + pathToSecondary.replace(/\\/g, '/');
+    const relSecondaryPath = !pathToSecondary ? '.' : './' + pathToSecondary.replace(/\\/g, '/');
     let secondaryEntryPoint = undefined;
-    const packageJsonExportsEntry = Object.keys(mainPkgJson?.exports ?? []).find((e) => {
+    const packageJsonExportsEntry = Object.keys(mainPkgJson?.exports ?? []).find(e => {
         if (e === relSecondaryPath)
             return true;
         if (e === './*')
@@ -261,8 +251,8 @@ function _getPackageInfo(packageName, directory) {
             esm,
         };
     }
-    logger_1.logger.warn('No entry point found for ' + packageName);
-    logger_1.logger.warn("If you don't need this package, skip it in your federation.config.js or consider moving it into devDependencies in your package.json");
+    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) {
@@ -276,4 +266,3 @@ function getPkgFolder(packageName) {
     }
     return folder;
 }
-//# sourceMappingURL=package-info.js.map

package/src/lib/utils/rebuild-queue.d.ts

@@ -1,6 +1,19 @@
+export type TrackResult<T = never> = {
+    type: 'completed';
+    result: {
+        success: boolean;
+        cancelled?: boolean;
+    };
+} | {
+    type: 'interrupted';
+    value: T;
+};
 export declare class RebuildQueue {
     private activeBuilds;
     private buildCounter;
-    enqueue(rebuildFn: (signal: AbortSignal) => Promise<void>): Promise<void>;
+    track<T = never>(rebuildFn: (signal: AbortSignal) => Promise<{
+        success: boolean;
+        cancelled?: boolean;
+    }>, interruptPromise?: Promise<T>): Promise<TrackResult<T>>;
     dispose(): void;
 }