@softarc/native-federation 4.1.2 → 4.2.0

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

@@ -1,123 +0,0 @@
-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.d.ts

@@ -1,3 +0,0 @@
-export declare function hashFile(fileName: string): string;
-export type SriAlgorithm = 'sha256' | 'sha384' | 'sha512';
-export declare function integrityForFile(fileName: string, algorithm?: SriAlgorithm): string;

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

@@ -1,13 +0,0 @@
-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');
-}
-export function integrityForFile(fileName, algorithm = 'sha384') {
-    const fileBuffer = fs.readFileSync(fileName);
-    const hash = crypto.createHash(algorithm).update(fileBuffer).digest('base64');
-    return `${algorithm}-${hash}`;
-}

package/src/lib/utils/logger.js

@@ -1,27 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import chalk from 'chalk';
-let verbose = false;
-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;
-        const [totalSeconds, nanoseconds] = process.hrtime(start);
-        const minutes = Math.floor(totalSeconds / 60);
-        const seconds = totalSeconds % 60;
-        const milliseconds = nanoseconds / 1000000;
-        const msFormatted = milliseconds.toFixed(3);
-        const timeStr = `${minutes.toString().padStart(2, '0')}:${seconds
-            .toString()
-            .padStart(2, '0')}:${msFormatted.padStart(7, '0')}ms`;
-        console.log(chalk.bgGreen.ansi256(15)(' DBG! '), `${timeStr} - ${milestone}`);
-    },
-};
-export const setLogLevel = (level) => {
-    verbose = level === 'verbose';
-};

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

@@ -1,33 +0,0 @@
-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 shareAll = !configuredSharedMappings;
-    if (!configuredSharedMappings) {
-        configuredSharedMappings = [];
-    }
-    const tsConfig = JSON5.parse(fs.readFileSync(rootTsConfigPath, { encoding: 'utf-8' }));
-    const mappings = tsConfig?.compilerOptions?.paths;
-    if (!mappings) {
-        return mappedPaths;
-    }
-    for (const key in mappings) {
-        const libPath = path.normalize(path.join(rootPath, mappings[key][0]));
-        if (configuredSharedMappings.includes(key) || shareAll) {
-            mappedPaths[libPath] = key;
-        }
-    }
-    return mappedPaths;
-}

package/src/lib/utils/normalize.js

@@ -1,17 +0,0 @@
-export function normalize(path, trailingSlash) {
-    let cand = path.replace(/\\/g, '/');
-    if (typeof trailingSlash === 'undefined') {
-        return cand;
-    }
-    while (cand.endsWith('/')) {
-        cand = cand.substring(0, cand.length - 1);
-    }
-    if (trailingSlash) {
-        return cand + '/';
-    }
-    return cand;
-}
-export function normalizePackageName(fileName) {
-    const sanitized = fileName.replace(/[^A-Za-z0-9]/g, '_');
-    return sanitized.startsWith('_') ? sanitized.slice(1) : sanitized;
-}

package/src/lib/utils/package-info.d.ts

@@ -1,30 +0,0 @@
-export interface PackageInfo {
-    packageName: string;
-    entryPoint: string;
-    version: string;
-    esm: boolean;
-}
-export interface PartialPackageJson {
-    module: string;
-    main: string;
-}
-export type VersionMap = Record<string, string>;
-export type PackageJsonInfo = {
-    content: any;
-    directory: string;
-};
-export type ExportCondition = 'import' | 'require' | 'node' | 'cjs' | 'esm' | 'default' | 'types' | 'browser' | (string & {});
-export declare const isESMExport: (e: string) => boolean | undefined;
-export type ExportEntry = string | undefined | {
-    [key in ExportCondition]?: ExportEntry;
-} | ExportEntry[];
-export type PackageJsonExports = string | ExportEntry | {
-    [path: `.${string}`]: ExportEntry;
-};
-export declare function findPackageJsonFiles(project: string, workspace: string): string[];
-export declare function expandFolders(child: string, parent: string): string[];
-export declare function getPackageInfo(packageName: string, workspaceRoot: string): PackageInfo | null;
-export declare function getVersionMaps(project: string, workspace: string): VersionMap[];
-export declare function getPackageJsonFiles(project: string, workspace: string): PackageJsonInfo[];
-export declare function findDepPackageJson(packageName: string, projectRoot: string): string | null;
-export declare function _getPackageInfo(packageName: string, directory: string): PackageInfo | null;

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

@@ -1,268 +0,0 @@
-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
-    if (e === 'module' || e === 'esm' || /^es20\d{2}$/.test(e))
-        return true;
-    if (e === 'require')
-        return false;
-    // Common CJS conventions
-    if (e === 'cjs' || e === 'commonjs')
-        return false;
-    // Ambiguous
-    return undefined;
-};
-const packageCache = {};
-export function findPackageJsonFiles(project, workspace) {
-    return expandFolders(project, workspace)
-        .map(f => path.join(f, 'package.json'))
-        .filter(f => fs.existsSync(f));
-}
-export function expandFolders(child, parent) {
-    const result = [];
-    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 = normalize(path.dirname(current), true);
-        if (cand === current) {
-            break;
-        }
-        current = cand;
-    }
-    result.push(parent);
-    return result;
-}
-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);
-        if (cand) {
-            return cand;
-        }
-    }
-    logger.warn('No meta data found for shared lib ' + packageName);
-    return null;
-}
-function getVersionMapCacheKey(project, workspace) {
-    return `${project}**${workspace}`;
-}
-export function getVersionMaps(project, workspace) {
-    return getPackageJsonFiles(project, workspace).map(json => ({
-        ...json.content['dependencies'],
-    }));
-}
-export 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(fs.readFileSync(f, 'utf-8'));
-        const directory = normalize(path.dirname(f), true);
-        const result = {
-            content,
-            directory,
-        };
-        return result;
-    });
-    packageCache[cacheKey] = maps;
-    return maps;
-}
-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;
-    while (path.dirname(directory) !== directory) {
-        if (fs.existsSync(mainPkgJsonPath)) {
-            break;
-        }
-        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.verbose('No package.json found for ' + packageName + ' in ' + mainPkgPath);
-        return null;
-    }
-    return mainPkgJsonPath;
-}
-function replaceGlob(target, replacement) {
-    if (!target)
-        return undefined;
-    if (typeof target === 'string')
-        return target.replace('*', replacement);
-    return Object.entries(target).reduce((a, [k, v]) => ({
-        ...a,
-        [k]: replaceGlob(v, replacement),
-    }), {});
-}
-function findOptimalExport(target, info, isESM = undefined) {
-    if (typeof target === 'string') {
-        return {
-            ...info,
-            entryPoint: path.join(info.entryPoint, target),
-            esm: isESM ?? info.esm,
-        };
-    }
-    if (!target)
-        return undefined;
-    if (Array.isArray(target))
-        return findOptimalExport(target[0], info, isESM);
-    const exportTypes = Object.keys(target);
-    // We prefer ESM exports for native support.
-    if (typeof isESM === 'undefined') {
-        const esmExport = exportTypes.find(e => isESMExport(e));
-        if (esmExport) {
-            return findOptimalExport(target[esmExport], info, true);
-        }
-    }
-    // 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];
-    const secondBestExport = target[secondBestEntry];
-    return findOptimalExport(secondBestExport, info, isESM ?? isESMExport(secondBestEntry));
-}
-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;
-    }
-    const mainPkgPath = path.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;
-    }
-    const pathToSecondary = path.relative(mainPkgName, packageName);
-    const relSecondaryPath = !pathToSecondary ? '.' : './' + pathToSecondary.replace(/\\/g, '/');
-    let secondaryEntryPoint = undefined;
-    const packageJsonExportsEntry = Object.keys(mainPkgJson?.exports ?? []).find(e => {
-        if (e === relSecondaryPath)
-            return true;
-        if (e === './*')
-            return true;
-        if (!e.endsWith('*'))
-            return false;
-        const globPath = e.substring(0, e.length - 1);
-        return relSecondaryPath.startsWith(globPath);
-    });
-    if (packageJsonExportsEntry) {
-        secondaryEntryPoint = mainPkgJson?.exports?.[packageJsonExportsEntry];
-        if (packageJsonExportsEntry.endsWith('*')) {
-            const replacement = relSecondaryPath.substring(packageJsonExportsEntry.length - 1);
-            secondaryEntryPoint = replaceGlob(secondaryEntryPoint, replacement);
-        }
-    }
-    if (secondaryEntryPoint) {
-        const info = findOptimalExport(secondaryEntryPoint, {
-            entryPoint: mainPkgPath,
-            packageName,
-            version,
-            esm,
-        });
-        if (info)
-            return info;
-    }
-    if (mainPkgJson['module'] && relSecondaryPath === '.') {
-        return {
-            entryPoint: path.join(mainPkgPath, mainPkgJson['module']),
-            packageName,
-            version,
-            esm: true,
-        };
-    }
-    const secondaryPgkPath = path.join(mainPkgPath, relSecondaryPath);
-    const secondaryPgkJsonPath = path.join(secondaryPgkPath, 'package.json');
-    let secondaryPgkJson = null;
-    if (fs.existsSync(secondaryPgkJsonPath)) {
-        secondaryPgkJson = readJson(secondaryPgkJsonPath);
-    }
-    if (secondaryPgkJson && secondaryPgkJson.module) {
-        return {
-            entryPoint: path.join(secondaryPgkPath, secondaryPgkJson.module),
-            packageName,
-            version,
-            esm: true,
-        };
-    }
-    let cand = path.join(secondaryPgkPath, 'index.mjs');
-    if (fs.existsSync(cand)) {
-        return {
-            entryPoint: cand,
-            packageName,
-            version,
-            esm: true,
-        };
-    }
-    if (secondaryPgkJson && secondaryPgkJson.main) {
-        return {
-            entryPoint: path.join(secondaryPgkPath, secondaryPgkJson.main),
-            packageName,
-            version,
-            esm,
-        };
-    }
-    cand = path.join(secondaryPgkPath, 'index.js');
-    if (fs.existsSync(cand)) {
-        return {
-            entryPoint: cand,
-            packageName,
-            version,
-            esm,
-        };
-    }
-    cand = secondaryPgkPath + '.js';
-    if (fs.existsSync(cand)) {
-        return {
-            entryPoint: cand,
-            packageName,
-            version,
-            esm,
-        };
-    }
-    cand = secondaryPgkPath + '.mjs';
-    if (fs.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(fs.readFileSync(mainPkgJsonPath, 'utf-8'));
-}
-function getPkgFolder(packageName) {
-    const parts = packageName.split('/');
-    let folder = parts[0];
-    if (folder.startsWith('@')) {
-        folder += '/' + parts[1];
-    }
-    return folder;
-}

package/src/lib/utils/rebuild-queue.js

@@ -1,63 +0,0 @@
-import { logger } from './logger.js';
-export class RebuildQueue {
-    activeBuilds = new Map();
-    buildCounter = 0;
-    async track(rebuildFn, interruptPromise) {
-        const buildId = ++this.buildCounter;
-        const pendingCancellations = Array.from(this.activeBuilds.values()).map(buildControl => {
-            buildControl.controller.abort();
-            return buildControl.buildFinished.promise;
-        });
-        if (pendingCancellations.length > 0) {
-            logger.info(`Aborting ${pendingCancellations.length} bundling task(s)..`);
-            await Promise.all(pendingCancellations);
-        }
-        let resolveCompletion;
-        const completionPromise = new Promise(resolve => {
-            resolveCompletion = resolve;
-        });
-        const control = {
-            controller: new AbortController(),
-            buildFinished: {
-                resolve: resolveCompletion,
-                promise: completionPromise,
-            },
-        };
-        this.activeBuilds.set(buildId, control);
-        const buildPromise = rebuildFn(control.controller.signal)
-            .then(result => ({ type: 'completed', result }))
-            .catch(error => ({ type: 'completed', result: { success: false, error } }));
-        let trackResult;
-        try {
-            if (interruptPromise) {
-                const interruptResult = interruptPromise.then(value => ({
-                    type: 'interrupted',
-                    value,
-                }));
-                const raceResult = await Promise.race([buildPromise, interruptResult]);
-                if (raceResult.type === 'interrupted') {
-                    control.controller.abort();
-                    await buildPromise;
-                    trackResult = raceResult;
-                }
-                else {
-                    trackResult = raceResult;
-                }
-            }
-            else {
-                trackResult = await buildPromise;
-            }
-        }
-        finally {
-            control.buildFinished.resolve();
-            this.activeBuilds.delete(buildId);
-        }
-        return trackResult;
-    }
-    dispose() {
-        for (const buildControl of this.activeBuilds.values()) {
-            buildControl.controller.abort();
-        }
-        this.activeBuilds.clear();
-    }
-}

package/src/lib/utils/resolve-glob.d.ts

@@ -1 +0,0 @@
-export declare function resolveGlobSync(pattern: string, baseDir?: string): string[];

package/src/lib/utils/resolve-glob.js

@@ -1,29 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-export function resolveGlobSync(pattern, baseDir = process.cwd()) {
-    if (pattern.startsWith('./')) {
-        pattern = pattern.substring(2);
-    }
-    const segments = pattern.split('/').filter(Boolean);
-    const results = [];
-    function search(dir, segmentIndex) {
-        if (segmentIndex >= segments.length) {
-            results.push(dir);
-            return;
-        }
-        const segment = segments[segmentIndex];
-        const entries = fs.readdirSync(dir, { withFileTypes: true });
-        if (segment === '*') {
-            entries
-                .filter(entry => entry.isDirectory())
-                .forEach(entry => search(path.join(dir, entry.name), segmentIndex + 1));
-        }
-        else {
-            entries
-                .filter(entry => entry.name === segment)
-                .forEach(entry => search(path.join(dir, entry.name), segmentIndex + 1));
-        }
-    }
-    search(baseDir, 0);
-    return results;
-}

package/src/lib/utils/resolve-wildcard-keys.d.ts

@@ -1,29 +0,0 @@
-export type KeyValuePair = {
-    key: string;
-    value: string;
-};
-/**
- * Resolves tsconfig wildcard paths.
- *
- * In tsconfig.json, paths like `@features/*` → `libs/features/src/*` work as follows:
- * - The `*` captures a single path segment (the module name)
- * - When importing `@features/feature-a`, TypeScript captures `feature-a`
- * - It then replaces `*` in the value pattern: `libs/features/src/feature-a`
- *
- * For discovery, we find all directories at the wildcard position that TypeScript
- * would recognize as valid modules (directories with index files or package.json).
- *
-// @see https://www.typescriptlang.org/docs/handbook/modules/theory.html#module-resolution
- */
-export declare function resolveTsConfigWildcard(keyPattern: string, valuePattern: string, cwd: string): KeyValuePair[];
-/**
- * Resolves package.json exports wildcard patterns.
- *
- * In package.json exports, patterns like `./features/*.js` → `./src/features/*.js` work as follows:
- * - The `*` is a literal string replacement that can include path separators
- * - Importing `pkg/features/a/b.js` captures `a/b` and replaces `*` → `./src/features/a/b.js`
- * - This matches actual files, not directories
- *
- * @see https://nodejs.org/api/packages.html#subpath-patterns
- */
-export declare function resolvePackageJsonExportsWildcard(keyPattern: string, valuePattern: string, cwd: string): KeyValuePair[];