@softarc/native-federation 4.0.0-RC9 → 4.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@softarc/native-federation",
-  "version": "4.0.0-RC9",
+  "version": "4.0.1",
   "type": "module",
   "license": "MIT",
   "dependencies": {
@@ -8,7 +8,7 @@
     "chalk": "^5.6.2",
     "fast-glob": "^3.3.3",
     "json5": "^2.2.3",
-    "esbuild": "^0.27.0"
+    "esbuild": "^0.28.0"
   },
   "exports": {
     "./package.json": "./package.json",

package/src/internal.d.ts

@@ -11,3 +11,5 @@ export type { NormalizedExternalConfig, NormalizedSharedExternalsConfig, } from
 export type { NormalizedFederationConfig } from './lib/domain/config/federation-config.contract.js';
 export { getDefaultCachePath, getChecksum } from './lib/utils/cache-persistence.js';
 export { isInSkipList, prepareSkipList } from './lib/config/default-skip-list.js';
+export { NfFileWatcher, NfFileWatcherOptions } from './lib/domain/utils/file-watcher.contract.js';
+export { syncNfFileWatcher, createNfWatcher } from './lib/utils/file-watcher.js';

package/src/internal.js

@@ -8,3 +8,4 @@ export { createBuildResultMap, lookupInResultMap, popFromResultMap, } from './li
 export { writeImportMap } from './lib/core/write-import-map.js';
 export { getDefaultCachePath, getChecksum } from './lib/utils/cache-persistence.js';
 export { isInSkipList, prepareSkipList } from './lib/config/default-skip-list.js';
+export { syncNfFileWatcher, createNfWatcher } from './lib/utils/file-watcher.js';

package/src/lib/core/bundle-exposed-and-mappings.js

@@ -55,7 +55,10 @@ export async function bundleExposedAndMappings(config, fedOptions, externals, mo
         }
         throw error;
     }
-    const resultMap = createBuildResultMap(result, hash);
+    const resultMap = createBuildResultMap(result, hash, [
+        ...shared.map(s => s.outName),
+        ...exposes.map(e => e.outName),
+    ]);
     const sharedResult = [];
     const entryFiles = [];
     // Pick shared-mappings

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

@@ -27,6 +27,7 @@ export async function normalizeFederationOptions(options, cache) {
         ...options,
         entryPoints: options.entryPoints ?? Object.values(config.exposes ?? {}),
         projectName: resolveProjectName(options.projectName ?? config.name),
+        cacheExternalArtifacts: options.cacheExternalArtifacts ?? true,
         federationCache,
     };
     /**
@@ -46,11 +47,6 @@ export async function normalizeFederationOptions(options, cache) {
                 .reduce((acc, [_path, _import]) => ({ ...acc, [_path]: _import }), {});
         }
     }
-    /**
-     * Step 4: Verify imports
-     */
-    checkForInvalidImports(Object.values(config.sharedMappings), 'shared mappings');
-    checkForInvalidImports(Object.keys(config.shared), 'externals');
     return { config, options: normalizedOptions };
 }
 export function resolveProjectName(name) {
@@ -60,31 +56,3 @@ export function resolveProjectName(name) {
     }
     return normalizePackageName(name);
 }
-const ALLOWED_FILE_EXTENSIONS = new Set(['mjs', 'js', 'mts', 'ts', 'jsx', 'tsx', 'json']);
-function checkForInvalidImports(importList, type) {
-    const importsWithDot = [];
-    for (const mappingImport of importList) {
-        if (mappingImport.indexOf('.') < 0) {
-            continue;
-        }
-        const queryIndex = mappingImport.search(/[?#]/);
-        const sanitizedImport = queryIndex >= 0 ? mappingImport.slice(0, queryIndex) : mappingImport;
-        const segmentStart = sanitizedImport.lastIndexOf('/') + 1;
-        const dotIndex = sanitizedImport.lastIndexOf('.');
-        if (dotIndex < segmentStart) {
-            importsWithDot.push(mappingImport);
-            continue;
-        }
-        const extension = sanitizedImport.slice(dotIndex + 1);
-        if (!ALLOWED_FILE_EXTENSIONS.has(extension)) {
-            importsWithDot.push(mappingImport);
-        }
-    }
-    if (importsWithDot.length > 0) {
-        importsWithDot.forEach(e => {
-            logger.warn(`Import '${e}' contains a bad dot (.) import.`);
-        });
-        logger.debug('Bad import issue: https://github.com/vitejs/vite/issues/21036');
-        throw new Error(`Invalid '${type}' config. Invalid imports paths detected, consider using a barrel import instead. `);
-    }
-}

package/src/lib/domain/core/federation-options.contract.d.ts

@@ -18,4 +18,5 @@ export interface NormalizedFederationOptions<TBundlerCache = unknown> extends Fe
     federationCache: FederationCache<TBundlerCache>;
     entryPoints: string[];
     projectName: string;
+    cacheExternalArtifacts: boolean;
 }

package/src/lib/domain/utils/file-watcher.contract.d.ts

@@ -0,0 +1,10 @@
+export interface NfFileWatcherOptions {
+    onChange?: (path: string) => void;
+}
+export interface NfFileWatcher {
+    addPaths(paths: string | readonly string[]): void;
+    close(): Promise<void>;
+    get(): ReadonlySet<string>;
+    clear(): void;
+    mutate(fn: (dirtyPaths: Set<string>) => void): void;
+}

package/src/lib/domain/utils/file-watcher.contract.js

@@ -0,0 +1 @@
+export {};

package/src/lib/utils/build-result-map.d.ts

@@ -1,4 +1,4 @@
 import type { NFBuildAdapterResult } from '../domain/core/build-adapter.contract.js';
-export declare function createBuildResultMap(buildResult: NFBuildAdapterResult[], isHashed: boolean): Record<string, string>;
+export declare function createBuildResultMap(buildResult: NFBuildAdapterResult[], isHashed: boolean, expectedNames?: string[]): Record<string, string>;
 export declare function lookupInResultMap(map: Record<string, string>, requestName: string): string;
 export declare function popFromResultMap(map: Record<string, string>, requestName: string): string;

package/src/lib/utils/build-result-map.js

@@ -1,16 +1,17 @@
 import path from 'path';
-export function createBuildResultMap(buildResult, isHashed) {
+function stripHash(fileName) {
+    const start = fileName.lastIndexOf('-');
+    const end = fileName.lastIndexOf('.');
+    if (start < 0 || end < 0 || start > end)
+        return fileName;
+    return fileName.substring(0, start) + fileName.substring(end);
+}
+export function createBuildResultMap(buildResult, isHashed, expectedNames = []) {
+    const expected = new Set(expectedNames.map(n => path.basename(n)));
     const map = {};
     for (const item of buildResult) {
         const resultName = path.basename(item.fileName);
-        let requestName = resultName;
-        if (isHashed) {
-            const start = resultName.lastIndexOf('-');
-            const end = resultName.lastIndexOf('.');
-            const part1 = resultName.substring(0, start);
-            const part2 = resultName.substring(end);
-            requestName = part1 + part2;
-        }
+        const requestName = isHashed && expected.has(stripHash(resultName)) ? stripHash(resultName) : resultName;
         map[requestName] = item.fileName;
     }
     return map;

package/src/lib/utils/file-watcher.d.ts

@@ -0,0 +1,5 @@
+import type { NfFileWatcher, NfFileWatcherOptions } from '../domain/utils/file-watcher.contract.js';
+export declare function createNfWatcher(options?: NfFileWatcherOptions): NfFileWatcher;
+export declare function syncNfFileWatcher(watcher: NfFileWatcher, bundlerCache: {
+    keys(): IterableIterator<string>;
+}): void;

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

@@ -0,0 +1,51 @@
+import { logger } from '@softarc/native-federation/internal';
+import { watch, statSync } from 'fs';
+import { join } from 'path';
+const toUnix = (p) => p.replace(/\\/g, '/');
+export function createNfWatcher(options = {}) {
+    const { onChange } = options;
+    const watchers = new Map();
+    const dirtyPaths = new Set();
+    const notify = (path) => {
+        if (onChange)
+            onChange(path);
+        else
+            dirtyPaths.add(path);
+    };
+    return {
+        addPaths(paths) {
+            const list = typeof paths === 'string' ? [paths] : [...paths];
+            for (const p of list) {
+                if (watchers.has(p))
+                    continue;
+                try {
+                    const isDir = statSync(p).isDirectory();
+                    const w = isDir
+                        ? watch(p, { recursive: true }, (_, filename) => {
+                            if (filename)
+                                notify(toUnix(join(p, filename)));
+                        })
+                        : watch(p, () => notify(toUnix(p)));
+                    watchers.set(p, w);
+                }
+                catch {
+                    logger.debug(`Could not watch path '${p}'.`);
+                }
+            }
+        },
+        get: () => dirtyPaths,
+        clear: () => dirtyPaths.clear(),
+        mutate: fn => fn(dirtyPaths),
+        async close() {
+            for (const w of watchers.values()) {
+                w.close();
+            }
+            watchers.clear();
+        },
+    };
+}
+export function syncNfFileWatcher(watcher, bundlerCache) {
+    const files = [...bundlerCache.keys()].filter(k => !k.includes('node_modules'));
+    if (files.length)
+        watcher.addPaths(files);
+}