@softarc/native-federation 4.0.0-RC8 → 4.0.0

package/src/lib/utils/resolve-wildcard-keys.js

@@ -1,45 +1,111 @@
 import fg from 'fast-glob';
-function escapeRegex(str) {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-// Convert package.json exports pattern to glob pattern
-// * in exports means "one segment", but for glob we need **/* for deep matching
-// Src: https://hirok.io/posts/package-json-exports#exposing-all-package-files
-function convertExportsToGlob(pattern) {
-    return pattern.replace(/(?<!\*)\*(?!\*)/g, '**/*');
-}
-function compilePattern(pattern) {
-    const tokens = pattern.split(/(\*\*|\*)/);
-    const regexParts = [];
-    for (const token of tokens) {
-        if (token === '*') {
-            regexParts.push('(.*)');
+import * as fs from 'fs';
+import * as path from 'path';
+import { logger } from './logger.js';
+// TypeScript's module resolution for directories checks these in order
+// @see https://www.typescriptlang.org/docs/handbook/modules/theory.html#module-resolution
+const TS_INDEX_FILES = [
+    'index.ts',
+    'index.tsx',
+    'index.mts',
+    'index.cts',
+    'index.d.ts',
+    'index.js',
+    'index.jsx',
+    'index.mjs',
+    'index.cjs',
+];
+/**
+ * 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 function resolveTsConfigWildcard(keyPattern, valuePattern, cwd) {
+    const normalizedPattern = valuePattern.replace(/^\.?\/+/, '');
+    const asteriskIndex = normalizedPattern.indexOf('*');
+    if (asteriskIndex === -1) {
+        return [];
+    }
+    const prefix = normalizedPattern.substring(0, asteriskIndex);
+    const suffix = normalizedPattern.substring(asteriskIndex + 1);
+    const searchPath = path.join(cwd, prefix);
+    let entries;
+    try {
+        entries = fs.readdirSync(searchPath);
+    }
+    catch {
+        return [];
+    }
+    const keys = [];
+    for (const entry of entries) {
+        const entryPath = path.join(searchPath, entry);
+        let stats;
+        try {
+            stats = fs.statSync(entryPath);
         }
-        else {
-            regexParts.push(escapeRegex(token));
+        catch {
+            continue;
         }
-    }
-    return new RegExp(`^${regexParts.join('')}$`);
-}
-function withoutWildcard(template, wildcardValues) {
-    const tokens = template.split(/(\*\*|\*)/);
-    let result = '';
-    let i = 0;
-    for (const token of tokens) {
-        if (token === '*') {
-            result += wildcardValues[i++];
+        if (!stats.isDirectory()) {
+            // Skipping individual files, we only process modules
+            continue;
         }
-        else {
-            result += token;
+        let modulePath = path.join(prefix, entry, suffix).replace(/\\/g, '/');
+        const fullPath = path.join(cwd, modulePath);
+        let fullPathStats;
+        try {
+            fullPathStats = fs.statSync(fullPath);
         }
+        catch {
+            continue;
+        }
+        const key = keyPattern.replace('*', entry);
+        if (fullPathStats.isDirectory()) {
+            const indexFile = TS_INDEX_FILES.find(indexFile => fs.existsSync(path.join(fullPath, indexFile)));
+            if (!indexFile) {
+                logger.warn(`[shared-mappings] Internal lib '${key}' does not contain an entryPoint (barrel file).`);
+                continue;
+            }
+            modulePath = path.join(modulePath, indexFile);
+        }
+        else if (!fullPathStats.isFile()) {
+            continue;
+        }
+        keys.push({
+            key,
+            value: modulePath,
+        });
     }
-    return result;
+    return keys;
 }
-export function resolveWildcardKeys(keyPattern, valuePattern, cwd) {
+/**
+ * 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 function resolvePackageJsonExportsWildcard(keyPattern, valuePattern, cwd) {
     const normalizedPattern = valuePattern.replace(/^\.?\/+/, '');
-    const globPattern = convertExportsToGlob(normalizedPattern);
-    const regex = compilePattern(normalizedPattern);
-    const files = fg.sync(globPattern, {
+    const asteriskIndex = normalizedPattern.indexOf('*');
+    if (asteriskIndex === -1) {
+        return [];
+    }
+    const prefix = normalizedPattern.substring(0, asteriskIndex);
+    const suffix = normalizedPattern.substring(asteriskIndex + 1);
+    // fast-glob requires **/* pattern for matching files at any depth
+    const files = fg.sync(prefix + '**/*' + suffix, {
         cwd,
         onlyFiles: true,
         deep: Infinity,
@@ -47,11 +113,12 @@ export function resolveWildcardKeys(keyPattern, valuePattern, cwd) {
     const keys = [];
     for (const file of files) {
         const relPath = file.replace(/\\/g, '/').replace(/^\.\//, '');
-        const wildcards = relPath.match(regex);
-        if (!wildcards)
-            continue;
+        const captured = suffix
+            ? relPath.slice(prefix.length, -suffix.length)
+            : relPath.slice(prefix.length);
+        const key = keyPattern.replace('*', captured);
         keys.push({
-            key: withoutWildcard(keyPattern, wildcards.slice(1)),
+            key,
             value: relPath,
         });
     }

package/src/lib/core/default-server-deps-list.d.ts

@@ -1,2 +0,0 @@
-export declare const DEFAULT_SERVER_DEPS_LIST: string[];
-export declare const DEFAULT_SERVER_DEPS_SET: Set<string>;

package/src/lib/core/default-server-deps-list.js

@@ -1,6 +0,0 @@
-export const DEFAULT_SERVER_DEPS_LIST = [
-    '@angular/platform-server',
-    '@angular/platform-server/init',
-    '@angular/ssr',
-];
-export const DEFAULT_SERVER_DEPS_SET = new Set(DEFAULT_SERVER_DEPS_LIST);

package/src/lib/core/load-federation-config.d.ts

@@ -1,3 +0,0 @@
-import type { NormalizedFederationConfig } from '../domain/config/federation-config.contract.js';
-import type { FederationOptions } from '../domain/core/federation-options.contract.js';
-export declare function loadFederationConfig(fedOptions: FederationOptions): Promise<NormalizedFederationConfig>;

package/src/lib/core/load-federation-config.js

@@ -1,18 +0,0 @@
-import * as path from 'path';
-import * as fs from 'fs';
-import { removeUnusedDeps } from './remove-unused-deps.js';
-export async function loadFederationConfig(fedOptions) {
-    const fullConfigPath = path.join(fedOptions.workspaceRoot, fedOptions.federationConfig);
-    if (!fs.existsSync(fullConfigPath)) {
-        throw new Error('Expected ' + fullConfigPath);
-    }
-    const config = (await import(fullConfigPath))?.default;
-    if (config.features.ignoreUnusedDeps && !fedOptions.entryPoint) {
-        throw new Error(`The feature ignoreUnusedDeps needs the application's entry point. Please set it in your federation options!`);
-    }
-    if (config.features.ignoreUnusedDeps) {
-        // const entryPoint = path.join(fedOptions.workspaceRoot, fedOptions.entryPoint ?? '');
-        return removeUnusedDeps(config, fedOptions.entryPoint ?? '', fedOptions.workspaceRoot);
-    }
-    return config;
-}

package/src/lib/core/normalize-federation-options.d.ts

@@ -1,4 +0,0 @@
-import type { FederationCache } from '../../domain.js';
-import type { FederationOptions, NormalizedFederationOptions } from '../domain/core/federation-options.contract.js';
-export declare function normalizeFederationOptions(options: FederationOptions): NormalizedFederationOptions<undefined>;
-export declare function normalizeFederationOptions<TBundlerCache>(options: FederationOptions, cache: FederationCache<TBundlerCache>): NormalizedFederationOptions<TBundlerCache>;

package/src/lib/core/normalize-federation-options.js

@@ -1,10 +0,0 @@
-import { getDefaultCachePath } from '../utils/cache-persistence.js';
-import { createFederationCache } from './federation-cache.js';
-export function normalizeFederationOptions(options, cache) {
-    const federationCache = cache ??
-        createFederationCache(getDefaultCachePath(options.workspaceRoot));
-    return {
-        ...options,
-        federationCache,
-    };
-}

package/src/lib/core/remove-unused-deps.d.ts

@@ -1,2 +0,0 @@
-import type { NormalizedFederationConfig } from '../domain/config/federation-config.contract.js';
-export declare function removeUnusedDeps(config: NormalizedFederationConfig, main: string, workspaceRoot: string): NormalizedFederationConfig;

package/src/lib/core/remove-unused-deps.js

@@ -1,90 +0,0 @@
-import { getProjectData } from '@softarc/sheriff-core';
-import path from 'path';
-import fs from 'fs';
-import { cwd } from 'process';
-import { getPackageInfo } from '../utils/package-info.js';
-import { getExternalImports as extractExternalImports } from '../utils/get-external-imports.js';
-import { normalizePackageName } from '../utils/normalize.js';
-import { resolveProjectName } from '../utils/config-utils.js';
-export function removeUnusedDeps(config, main, workspaceRoot) {
-    const fileInfos = getProjectData(main, cwd(), {
-        includeExternalLibraries: true,
-    });
-    const usedDeps = findUsedDeps(fileInfos, workspaceRoot, config);
-    const usedPackageNames = usedDeps.usedPackageNames;
-    const usedMappings = usedDeps.usedMappings;
-    const projectName = resolveProjectName(config);
-    const usedPackageNamesWithTransient = addTransientDeps(usedPackageNames, workspaceRoot, projectName);
-    const filteredShared = filterShared(config, usedPackageNamesWithTransient);
-    return {
-        ...config,
-        shared: filteredShared,
-        sharedMappings: [...usedMappings],
-    };
-}
-function filterShared(config, usedPackageNamesWithTransient) {
-    return Object.entries(config.shared)
-        .filter(([shared, meta]) => !!meta.includeSecondaries || usedPackageNamesWithTransient.has(shared))
-        .reduce((acc, [shared, meta]) => ({ ...acc, [shared]: meta }), {});
-}
-function findUsedDeps(fileInfos, workspaceRoot, config) {
-    const usedPackageNames = new Set();
-    const usedMappings = new Set();
-    for (const fileName of Object.keys(fileInfos)) {
-        const fileInfo = fileInfos[fileName];
-        if (!fileInfo) {
-            continue;
-        }
-        const libs = [...(fileInfo.externalLibraries || []), ...(fileInfo.unresolvedImports || [])];
-        for (const pckg of libs) {
-            usedPackageNames.add(pckg);
-        }
-        const fullFileName = path.join(workspaceRoot, fileName);
-        const mappings = config.sharedMappings.filter(sm => fullFileName.startsWith(sm.path));
-        for (const mapping of mappings) {
-            usedMappings.add(mapping);
-        }
-    }
-    return { usedPackageNames, usedMappings };
-}
-function addTransientDeps(packages, workspaceRoot, projectName) {
-    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 = getExternalImports(pInfo, workspaceRoot, projectName);
-        for (const peerDep of peerDeps) {
-            if (!discovered.has(peerDep)) {
-                discovered.add(peerDep);
-                stack.push(peerDep);
-                packagesAndPeers.add(peerDep);
-            }
-        }
-    }
-    return packagesAndPeers;
-}
-function getExternalImports(pInfo, workspaceRoot, projectName) {
-    const encodedPackageName = normalizePackageName(pInfo.packageName);
-    const cacheFileName = `${encodedPackageName}-${pInfo.version}.deps.json`;
-    const cachePath = path.join(workspaceRoot, 'node_modules/.cache/native-federation/_externals-metadata', projectName);
-    const cacheFilePath = path.join(cachePath, cacheFileName);
-    const cacheHit = fs.existsSync(cacheFilePath);
-    let peerDeps;
-    if (cacheHit) {
-        peerDeps = JSON.parse(fs.readFileSync(cacheFilePath, 'utf-8'));
-    }
-    else {
-        peerDeps = extractExternalImports(pInfo.entryPoint);
-        fs.mkdirSync(cachePath, { recursive: true });
-        fs.writeFileSync(cacheFilePath, JSON.stringify(peerDeps, undefined, 2), 'utf-8');
-    }
-    return peerDeps;
-}

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

@@ -1,2 +0,0 @@
-import type { NormalizedFederationConfig } from '../domain/config/federation-config.contract.js';
-export declare function resolveProjectName(config: NormalizedFederationConfig): string;

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

@@ -1,9 +0,0 @@
-import { logger } from './logger.js';
-import { normalizePackageName } from './normalize.js';
-export function resolveProjectName(config) {
-    const normalizedProjectName = normalizePackageName(config.name);
-    if (normalizedProjectName.length < 1) {
-        logger.warn("Project name in 'federation.config.js' is empty, defaulting to 'shell' cache folder (could collide with other projects in the workspace).");
-    }
-    return normalizedProjectName.length < 1 ? 'shell' : normalizedProjectName;
-}