@softarc/native-federation 4.0.0-RC6 → 4.0.0-RC8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@softarc/native-federation",
-  "version": "4.0.0-RC6",
+  "version": "4.0.0-RC8",
   "type": "module",
   "license": "MIT",
   "dependencies": {

package/src/internal.d.ts

@@ -3,7 +3,7 @@ export { hashFile } from './lib/utils/hash-file.js';
 export * from './lib/utils/errors.js';
 export { logger, setLogLevel } from './lib/utils/logger.js';
 export type { MappedPath } from './lib/domain/utils/mapped-path.contract.js';
-export { RebuildQueue } from './lib/utils/rebuild-queue.js';
+export { RebuildQueue, type TrackResult } from './lib/utils/rebuild-queue.js';
 export { AbortedError } from './lib/utils/errors.js';
 export { createBuildResultMap, lookupInResultMap, popFromResultMap, } from './lib/utils/build-result-map.js';
 export { writeImportMap } from './lib/core/write-import-map.js';

package/src/lib/core/build-for-federation.js

@@ -9,16 +9,10 @@ import { resolveProjectName } from '../utils/config-utils.js';
 import { addExternalsToCache } from './federation-cache.js';
 import path from 'path';
 export async function buildForFederation(config, fedOptions, externals, signal) {
-    // 1. Caching
+    // 1. Setup
     fedOptions.federationCache.cachePath = path.join(fedOptions.federationCache.cachePath, resolveProjectName(config));
-    const start = process.hrtime();
-    // 2. Shared mappings and exposed modules
-    const artifactInfo = await bundleExposedAndMappings(config, fedOptions, externals, undefined, signal);
-    logger.measure(start, '[build artifacts] - To bundle all mappings and exposed.');
-    if (signal?.aborted)
-        throw new AbortedError('[buildForFederation] After exposed-and-mappings bundle');
-    const exposedInfo = !artifactInfo ? describeExposed(config, fedOptions) : artifactInfo.exposes;
-    // 3. Externals
+    logger.info('Building federation artifacts');
+    // 2. Externals
     if (fedOptions.federationCache.externals.length > 0) {
         logger.info('Checksum matched, re-using cached externals.');
     }
@@ -61,6 +55,13 @@ export async function buildForFederation(config, fedOptions, externals, signal)
         if (signal?.aborted)
             throw new AbortedError('[buildForFederation] After separate-node bundle');
     }
+    // 2. Shared mappings and exposed modules
+    const start = process.hrtime();
+    const artifactInfo = await bundleExposedAndMappings(config, fedOptions, externals, undefined, signal);
+    logger.measure(start, '[build artifacts] - To bundle all mappings and exposed.');
+    if (signal?.aborted)
+        throw new AbortedError('[buildForFederation] After exposed-and-mappings bundle');
+    const exposedInfo = !artifactInfo ? describeExposed(config, fedOptions) : artifactInfo.exposes;
     const sharedMappingInfo = !artifactInfo
         ? describeSharedMappings(config, fedOptions)
         : artifactInfo.mappings;

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

@@ -22,7 +22,6 @@ export async function bundleExposedAndMappings(config, fedOptions, externals, mo
     });
     const entryPoints = [...shared, ...exposes];
     const hash = !fedOptions.dev;
-    logger.info('Building federation artifacts');
     let result;
     try {
         if (!modifiedFiles) {

package/src/lib/domain/config/external-config.contract.d.ts

@@ -5,7 +5,7 @@ export interface ExternalConfig {
     version?: string;
     includeSecondaries?: boolean;
     platform?: 'browser' | 'node';
-    build?: 'default' | 'separate';
+    build?: 'default' | 'separate' | 'package';
     shareScope?: string;
     packageInfo?: {
         entryPoint: string;

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

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

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;
 }

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

@@ -2,41 +2,61 @@ import { logger } from './logger.js';
 export class RebuildQueue {
     activeBuilds = new Map();
     buildCounter = 0;
-    async enqueue(rebuildFn) {
+    async track(rebuildFn, interruptPromise) {
         const buildId = ++this.buildCounter;
-        const pendingCancellations = Array.from(this.activeBuilds.values()).map(buildInfo => {
-            buildInfo.controller.abort();
-            return buildInfo.buildFinished.promise;
+        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)..`);
-        }
-        if (pendingCancellations.length > 0) {
             await Promise.all(pendingCancellations);
         }
-        let buildFinished;
+        let resolveCompletion;
         const completionPromise = new Promise(resolve => {
-            buildFinished = resolve;
+            resolveCompletion = resolve;
         });
         const control = {
             controller: new AbortController(),
             buildFinished: {
-                resolve: 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 {
-            await rebuildFn(control.controller.signal);
+            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 [_, buildInfo] of this.activeBuilds) {
-            buildInfo.controller.abort();
+        for (const buildControl of this.activeBuilds.values()) {
+            buildControl.controller.abort();
         }
         this.activeBuilds.clear();
     }