@softarc/native-federation 4.0.0-RC1 → 4.0.0-RC10

package/src/lib/domain/config/index.d.ts

@@ -1,4 +1,3 @@
 export type { ExternalConfig, IncludeSecondariesOptions, SharedExternalsConfig, ShareAllExternalsOptions, ShareExternalsOptions, } from './external-config.contract.js';
 export type { FederationConfig } from './federation-config.contract.js';
 export type { PreparedSkipList, SkipFn, SkipList, SkipListEntry } from './skip-list.contract.js';
-//# sourceMappingURL=index.d.ts.map

package/src/lib/domain/config/skip-list.contract.d.ts

@@ -6,4 +6,3 @@ export type PreparedSkipList = {
     functions: SkipFn[];
     regexps: RegExp[];
 };
-//# sourceMappingURL=skip-list.contract.d.ts.map

package/src/lib/domain/config/with-native-federation.contract.d.ts

@@ -0,0 +1,2 @@
+import type { NormalizedFederationConfig } from './federation-config.contract.js';
+export type WithNativeFederation = NormalizedFederationConfig;

package/src/lib/domain/core/build-adapter.contract.d.ts

@@ -1,28 +1,40 @@
-import type { MappedPath } from '../utils/mapped-path.contract.js';
-export type NFBuildAdapter = (options: NFBuildAdapterOptions) => Promise<NFBuildAdapterResult[]>;
-export type BuildKind = 'shared-package' | 'shared-mapping' | 'exposed' | 'mapping-or-exposed';
+import type { PathToImport } from '../utils/mapped-path.contract.js';
+import type { FederationCache } from './federation-cache.contract.js';
+export interface NFBuildAdapterContext<TBundlerContext = unknown> {
+    ctx: TBundlerContext;
+    outdir: string;
+    dev: boolean;
+    name: string;
+    isMappingOrExposed: boolean;
+}
+export interface NFBuildAdapter {
+    setup(name: string, options: NFBuildAdapterOptions): Promise<void>;
+    build(name: string, opts?: {
+        modifiedFiles?: string[];
+        signal?: AbortSignal;
+    }): Promise<NFBuildAdapterResult[]>;
+    dispose(name?: string): Promise<void>;
+}
 export interface EntryPoint {
     fileName: string;
     outName: string;
     key?: string;
 }
-export interface NFBuildAdapterOptions {
+export interface NFBuildAdapterOptions<TBundlerCache = unknown> {
     entryPoints: EntryPoint[];
     tsConfigPath?: string;
-    external: Array<string>;
+    external: string[];
     outdir: string;
-    mappedPaths: MappedPath[];
-    packageName?: string;
-    esm?: boolean;
+    mappedPaths: PathToImport;
+    isMappingOrExposed: boolean;
     dev?: boolean;
     watch?: boolean;
-    kind: BuildKind;
+    chunks?: boolean;
     hash: boolean;
     platform?: 'browser' | 'node';
     optimizedMappings?: boolean;
-    signal?: AbortSignal;
+    cache: FederationCache<TBundlerCache>;
 }
 export interface NFBuildAdapterResult {
     fileName: string;
 }
-//# sourceMappingURL=build-adapter.contract.d.ts.map

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

@@ -7,4 +7,3 @@ export declare enum BuildNotificationType {
     ERROR = "federation-rebuild-error",
     CANCELLED = "federation-rebuild-cancelled"
 }
-//# sourceMappingURL=build-notification-options.contract.d.ts.map

package/src/lib/domain/core/chunk.d.ts

@@ -0,0 +1,2 @@
+export declare const CHUNK_PREFIX = "@nf-internal";
+export declare function toChunkImport(fileName: string): string;

package/src/lib/domain/core/chunk.js

@@ -0,0 +1,8 @@
+export const CHUNK_PREFIX = '@nf-internal';
+export function toChunkImport(fileName) {
+    if (fileName.startsWith('./')) {
+        fileName = fileName.slice(2);
+    }
+    const packageName = fileName.replace(/.(m|c)?js$/, '');
+    return CHUNK_PREFIX + '/' + packageName;
+}

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

@@ -0,0 +1,7 @@
+import type { ChunkInfo, SharedInfo } from './federation-info.contract.js';
+export type FederationCache<TBundlerCache = unknown> = {
+    externals: SharedInfo[];
+    chunks?: ChunkInfo;
+    bundlerCache: TBundlerCache;
+    cachePath: string;
+};

package/src/lib/domain/core/federation-cache.contract.js

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

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

@@ -2,6 +2,7 @@ export interface FederationInfo {
     name: string;
     exposes: ExposesInfo[];
     shared: SharedInfo[];
+    chunks?: Record<string, string[]>;
     buildNotificationsEndpoint?: string;
 }
 export type SharedInfo = {
@@ -10,11 +11,14 @@ export type SharedInfo = {
     requiredVersion: string;
     version?: string;
     packageName: string;
+    shareScope?: string;
+    bundle?: string;
     outFileName: string;
     dev?: {
         entryPoint: string;
     };
 };
+export type ChunkInfo = Record<string, string[]>;
 export interface ExposesInfo {
     key: string;
     outFileName: string;
@@ -22,8 +26,8 @@ export interface ExposesInfo {
         entryPoint: string;
     };
 }
-export interface ArtefactInfo {
+export interface ArtifactInfo {
     mappings: SharedInfo[];
     exposes: ExposesInfo[];
+    chunks?: ChunkInfo;
 }
-//# sourceMappingURL=federation-info.contract.d.ts.map

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

@@ -1,15 +1,21 @@
 import type { BuildNotificationOptions } from './build-notification-options.contract.js';
+import type { FederationCache } from './federation-cache.contract.js';
 export interface FederationOptions {
     workspaceRoot: string;
     outputPath: string;
     federationConfig: string;
+    projectName?: string;
     cacheExternalArtifacts?: boolean;
     tsConfig?: string;
     verbose?: boolean;
     dev?: boolean;
     watch?: boolean;
     packageJson?: string;
-    entryPoint?: string;
+    entryPoints?: string[];
     buildNotifications?: BuildNotificationOptions;
 }
-//# sourceMappingURL=federation-options.contract.d.ts.map
+export interface NormalizedFederationOptions<TBundlerCache = unknown> extends FederationOptions {
+    federationCache: FederationCache<TBundlerCache>;
+    entryPoints: string[];
+    projectName: string;
+}

package/src/lib/domain/core/index.d.ts

@@ -1,6 +1,6 @@
-export type { SharedInfo, FederationInfo, ExposesInfo, ArtefactInfo, } from './federation-info.contract.js';
+export type { SharedInfo, FederationInfo, ExposesInfo, ArtifactInfo, ChunkInfo, } from './federation-info.contract.js';
 export { type BuildNotificationOptions, BuildNotificationType, } from './build-notification-options.contract.js';
-export type { FederationOptions } from './federation-options.contract.js';
-export type { BuildKind, EntryPoint, NFBuildAdapterOptions, NFBuildAdapter, NFBuildAdapterResult, } from './build-adapter.contract.js';
-export type { BuildParams } from './build-params.contract.js';
-//# sourceMappingURL=index.d.ts.map
+export type { FederationOptions, NormalizedFederationOptions, } from './federation-options.contract.js';
+export type { EntryPoint, NFBuildAdapterOptions, NFBuildAdapter, NFBuildAdapterResult, NFBuildAdapterContext, } from './build-adapter.contract.js';
+export { CHUNK_PREFIX, toChunkImport } from './chunk.js';
+export type { FederationCache } from './federation-cache.contract.js';

package/src/lib/domain/core/index.js

@@ -1 +1,2 @@
 export { BuildNotificationType, } from './build-notification-options.contract.js';
+export { CHUNK_PREFIX, toChunkImport } from './chunk.js';

package/src/lib/domain/utils/index.d.ts

@@ -1,3 +1,2 @@
 export type { KeyValuePair } from './keyvaluepair.contract.js';
-export type { MappedPath } from './mapped-path.contract.js';
-//# sourceMappingURL=index.d.ts.map
+export type { PathToImport } from './mapped-path.contract.js';

package/src/lib/domain/utils/keyvaluepair.contract.d.ts

@@ -2,4 +2,3 @@ export type KeyValuePair = {
     key: string;
     value: string;
 };
-//# sourceMappingURL=keyvaluepair.contract.d.ts.map

package/src/lib/domain/utils/mapped-path.contract.d.ts

@@ -1,5 +1 @@
-export interface MappedPath {
-    key: string;
-    path: string;
-}
-//# sourceMappingURL=mapped-path.contract.d.ts.map
+export type PathToImport = Record<string, string>;

package/src/lib/domain/utils/mapped-path.contract.js

@@ -1 +1,5 @@
+// export interface MappedPath {
+//   key: string;
+//   path: string;
+// }
 export {};

package/src/lib/domain/utils/used-dependencies.contract.d.ts

@@ -0,0 +1,5 @@
+import type { PathToImport } from './mapped-path.contract.js';
+export type UsedDependencies = {
+    external: Set<string>;
+    internal: PathToImport;
+};

package/src/lib/domain/utils/used-dependencies.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 lookupInResultMap(map: Record<string, string>, requestName: string): string;
-//# sourceMappingURL=build-result-map.d.ts.map
+export declare function popFromResultMap(map: Record<string, string>, requestName: string): string;

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

@@ -11,11 +11,18 @@ export function createBuildResultMap(buildResult, isHashed) {
             const part2 = resultName.substring(end);
             requestName = part1 + part2;
         }
-        map[requestName] = resultName;
+        map[requestName] = item.fileName;
     }
     return map;
 }
 export function lookupInResultMap(map, requestName) {
     const key = path.basename(requestName);
-    return map[key];
+    // path.basename is to maintain backwards compatible
+    return path.basename(map[key]);
+}
+export function popFromResultMap(map, requestName) {
+    const key = path.basename(requestName);
+    const out = map[key];
+    delete map[key];
+    return out;
 }

package/src/lib/utils/{bundle-caching.d.ts → cache-persistence.d.ts}

@@ -1,20 +1,21 @@
 import type { NormalizedExternalConfig } from '../domain/config/external-config.contract.js';
-import type { SharedInfo } from '../domain/core/federation-info.contract.js';
-export declare const getCachePath: (workspaceRoot: string, project: string) => string;
+import type { ChunkInfo, SharedInfo } from '../domain/core/federation-info.contract.js';
+export declare const getDefaultCachePath: (workspaceRoot: string) => string;
 export declare const getFilename: (title: string, dev?: boolean) => string;
 export declare const getChecksum: (shared: Record<string, NormalizedExternalConfig>, dev: "1" | "0") => string;
 export declare const cacheEntry: (pathToCache: string, fileName: string) => {
     getMetadata: (checksum: string) => {
         checksum: string;
         externals: SharedInfo[];
+        chunks?: ChunkInfo;
         files: string[];
     } | undefined;
     persist: (payload: {
         checksum: string;
         externals: SharedInfo[];
+        chunks?: ChunkInfo;
         files: string[];
     }) => void;
     copyFiles: (fullOutputPath: string) => void;
     clear: () => void;
 };
-//# sourceMappingURL=bundle-caching.d.ts.map

package/src/lib/utils/{bundle-caching.js → cache-persistence.js}

@@ -1,8 +1,8 @@
 import path from 'path';
 import fs from 'fs';
 import crypto from 'crypto';
-import { logger } from '../utils/logger.js';
-export const getCachePath = (workspaceRoot, project) => path.join(workspaceRoot, 'node_modules/.cache/native-federation', project);
+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`;

package/src/lib/utils/errors.d.ts

@@ -1,4 +1,3 @@
 export declare class AbortedError extends Error {
     constructor(message: string);
 }
-//# sourceMappingURL=errors.d.ts.map

package/src/lib/utils/get-external-imports.d.ts

@@ -1,2 +1 @@
 export declare function getExternalImports(entryFilePath: string): string[];
-//# sourceMappingURL=get-external-imports.d.ts.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.d.ts

@@ -1,2 +1 @@
 export declare function hashFile(fileName: string): string;
-//# sourceMappingURL=hash-file.d.ts.map

package/src/lib/utils/logger.d.ts

@@ -8,4 +8,3 @@ export declare const logger: {
     measure: (start: [number, number], milestone: string) => void;
 };
 export declare const setLogLevel: (level: string) => void;
-//# sourceMappingURL=logger.d.ts.map

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

@@ -1,8 +1,7 @@
-import type { MappedPath } from '../domain/utils/mapped-path.contract.js';
-export interface GetMappedPathsOptions {
-    rootTsConfigPath: string;
-    sharedMappings?: string[];
-    rootPath?: string;
-}
-export declare function getMappedPaths({ rootTsConfigPath, sharedMappings, rootPath, }: GetMappedPathsOptions): Array<MappedPath>;
-//# sourceMappingURL=mapped-paths.d.ts.map
+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,31 +1,33 @@
 import * as path from 'path';
 import * as fs from 'fs';
 import JSON5 from 'json5';
-export function getMappedPaths({ rootTsConfigPath, sharedMappings, rootPath, }) {
-    const result = [];
+/**
+ * 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 = !sharedMappings;
-    if (!sharedMappings) {
-        sharedMappings = [];
+    const shareAll = !configuredSharedMappings;
+    if (!configuredSharedMappings) {
+        configuredSharedMappings = [];
     }
     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) {
         const libPath = path.normalize(path.join(rootPath, mappings[key][0]));
-        if (sharedMappings.includes(key) || shareAll) {
-            result.push({
-                key,
-                path: libPath,
-            });
+        if (configuredSharedMappings.includes(key) || shareAll) {
+            mappedPaths[libPath] = key;
         }
     }
-    return result;
+    return mappedPaths;
 }

package/src/lib/utils/normalize.d.ts

@@ -1,3 +1,2 @@
 export declare function normalize(path: string, trailingSlash?: boolean): string;
 export declare function normalizePackageName(fileName: string): string;
-//# sourceMappingURL=normalize.d.ts.map

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

@@ -28,4 +28,3 @@ export declare function getVersionMaps(project: string, workspace: string): Vers
 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;
-//# sourceMappingURL=package-info.d.ts.map

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

@@ -1,7 +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;
 }
-//# sourceMappingURL=rebuild-queue.d.ts.map

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

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

@@ -1,2 +1 @@
 export declare function resolveGlobSync(pattern: string, baseDir?: string): string[];
-//# sourceMappingURL=resolve-glob.d.ts.map

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

@@ -15,13 +15,13 @@ export function resolveGlobSync(pattern, baseDir = process.cwd()) {
         const entries = fs.readdirSync(dir, { withFileTypes: true });
         if (segment === '*') {
             entries
-                .filter((entry) => entry.isDirectory())
-                .forEach((entry) => search(path.join(dir, entry.name), segmentIndex + 1));
+                .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));
+                .filter(entry => entry.name === segment)
+                .forEach(entry => search(path.join(dir, entry.name), segmentIndex + 1));
         }
     }
     search(baseDir, 0);