perf(nf-core): less calls to esbuild

Author: manfredsteyer

libs/native-federation-core/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@softarc/native-federation",
-  "version": "1.1.2",
+  "version": "2.0.0",
   "type": "commonjs",
   "dependencies": {
     "json5": "^2.2.0",
     "npmlog": "^6.0.2",
-    "@softarc/native-federation-runtime": "1.1.2"
+    "@softarc/native-federation-runtime": "2.0.0"
   }
 }

libs/native-federation-core/src/build.ts

@@ -3,13 +3,15 @@ export { FederationOptions } from './lib/core/federation-options';
 export { setBuildAdapter } from './lib/core/build-adapter';
 export { writeImportMap } from './lib/core/write-import-map';
 export { writeFederationInfo } from './lib/core/write-federation-info';
-export { bundleShared } from './lib/core/bundle-shared';
-export { bundleSharedMappings } from './lib/core/bundle-shared-mappings';
-export { bundleExposed } from './lib/core/bundle-exposed';
 export { getExternals } from './lib/core/get-externals';
 export { loadFederationConfig } from './lib/core/load-federation-config';
 export { MappedPath } from './lib/utils/mapped-paths';
-export { BuildAdapter, BuildAdapterOptions } from './lib/core/build-adapter';
+export {
+  BuildAdapter,
+  BuildAdapterOptions,
+  BuildResult,
+  BuildKind,
+} from './lib/core/build-adapter';
 export { withNativeFederation } from './lib/config/with-native-federation';
 export { buildForFederation } from './lib/core/build-for-federation';
 export {
@@ -23,3 +25,4 @@ export {
 } from './lib/core/federation-builder';
 export { logger, setLogLevel } from './lib/utils/logger';
 export { hashFile } from './lib/utils/hash-file';
+export * from './lib/utils/build-result-map';

libs/native-federation-core/src/lib/core/build-adapter.d.ts

@@ -1,17 +1,25 @@
 import { MappedPath } from '../utils/mapped-paths';
-export type BuildKind = 'shared-package' | 'shared-mapping' | 'exposed';
+export type BuildKind = 'shared-package' | 'shared-mapping' | 'exposed' | 'mapping-or-exposed';
+export interface EntryPoint {
+    fileName: string;
+    outName: string;
+}
 export interface BuildAdapterOptions {
-  entryPoint: string;
-  tsConfigPath?: string;
-  external: Array<string>;
-  outfile: string;
-  mappedPaths: MappedPath[];
-  packageName?: string;
-  esm?: boolean;
-  dev?: boolean;
-  watch?: boolean;
-  kind: BuildKind;
+    entryPoints: EntryPoint[];
+    tsConfigPath?: string;
+    external: Array<string>;
+    outdir: string;
+    mappedPaths: MappedPath[];
+    packageName?: string;
+    esm?: boolean;
+    dev?: boolean;
+    watch?: boolean;
+    kind: BuildKind;
+    hash: boolean;
+}
+export interface BuildResult {
+    fileName: string;
 }
-export type BuildAdapter = (options: BuildAdapterOptions) => Promise<void>;
+export type BuildAdapter = (options: BuildAdapterOptions) => Promise<BuildResult[]>;
 export declare function setBuildAdapter(buildAdapter: BuildAdapter): void;
 export declare function getBuildAdapter(): BuildAdapter;

libs/native-federation-core/src/lib/core/build-adapter.js

@@ -4,24 +4,41 @@ import { MappedPath } from '../utils/mapped-paths';
 let _buildAdapter: BuildAdapter = async () => {
   // TODO: add logger
   logger.error('Please set a BuildAdapter!');
+  return [];
 };
 
-export type BuildKind = 'shared-package' | 'shared-mapping' | 'exposed';
+export type BuildKind =
+  | 'shared-package'
+  | 'shared-mapping'
+  | 'exposed'
+  | 'mapping-or-exposed';
+
+export interface EntryPoint {
+  fileName: string;
+  outName: string;
+}
 
 export interface BuildAdapterOptions {
-  entryPoint: string;
+  entryPoints: EntryPoint[];
   tsConfigPath?: string;
   external: Array<string>;
-  outfile: string;
+  outdir: string;
   mappedPaths: MappedPath[];
   packageName?: string;
   esm?: boolean;
   dev?: boolean;
   watch?: boolean;
   kind: BuildKind;
+  hash: boolean;
+}
+
+export interface BuildResult {
+  fileName: string;
 }
 
-export type BuildAdapter = (options: BuildAdapterOptions) => Promise<void>;
+export type BuildAdapter = (
+  options: BuildAdapterOptions
+) => Promise<BuildResult[]>;
 
 export function setBuildAdapter(buildAdapter: BuildAdapter): void {
   _buildAdapter = buildAdapter;

libs/native-federation-core/src/lib/core/build-adapter.js.map

@@ -5,19 +5,18 @@ import { writeImportMap } from './write-import-map';
 import { writeFederationInfo } from './write-federation-info';
 import { bundleShared } from './bundle-shared';
 import {
-  bundleSharedMappings,
+  ArtefactInfo,
+  bundleExposedAndMappings,
+  describeExposed,
   describeSharedMappings,
-} from './bundle-shared-mappings';
-import { bundleExposed, describeExposed } from './bundle-exposed';
+} from './bundle-exposed-and-mappings';
 
 export interface BuildParams {
-  skipMappings: boolean;
-  skipExposed: boolean;
+  skipMappingsAndExposed: boolean;
 }
 
 export const defaultBuildParams: BuildParams = {
-  skipExposed: false,
-  skipMappings: false,
+  skipMappingsAndExposed: false,
 };
 
 export async function buildForFederation(
@@ -26,15 +25,24 @@ export async function buildForFederation(
   externals: string[],
   buildParams = defaultBuildParams
 ) {
-  const exposedInfo = buildParams.skipExposed
+  let artefactInfo: ArtefactInfo | undefined;
+  if (!buildParams.skipMappingsAndExposed) {
+    artefactInfo = await bundleExposedAndMappings(
+      config,
+      fedOptions,
+      externals
+    );
+  }
+
+  const exposedInfo = !artefactInfo
     ? describeExposed(config, fedOptions)
-    : await bundleExposed(config, fedOptions, externals);
+    : artefactInfo.exposes;
 
   const sharedPackageInfo = await bundleShared(config, fedOptions, externals);
 
-  const sharedMappingInfo = buildParams.skipMappings
+  const sharedMappingInfo = !artefactInfo
     ? describeSharedMappings(config, fedOptions)
-    : await bundleSharedMappings(config, fedOptions, externals);
+    : artefactInfo.mappings;
 
   const sharedInfo = [...sharedPackageInfo, ...sharedMappingInfo];
 

libs/native-federation-core/src/lib/core/build-adapter.ts

@@ -0,0 +1,137 @@
+import path from 'path';
+import { NormalizedFederationConfig } from '../config/federation-config';
+import { FederationOptions } from './federation-options';
+import { bundle } from '../utils/build-utils';
+import { ExposesInfo, SharedInfo } from '@softarc/native-federation-runtime';
+import {
+  createBuildResultMap,
+  lookupInResultMap,
+} from '../utils/build-result-map';
+import { logger } from '../utils/logger';
+
+export interface ArtefactInfo {
+  mappings: SharedInfo[];
+  exposes: ExposesInfo[];
+}
+
+export async function bundleExposedAndMappings(
+  config: NormalizedFederationConfig,
+  fedOptions: FederationOptions,
+  externals: string[]
+): Promise<ArtefactInfo> {
+  const shared = config.sharedMappings.map((sm) => {
+    const entryPoint = sm.path;
+    const tmp = sm.key.replace(/[^A-Za-z0-9]/g, '_');
+    const outFilePath = tmp + '.js';
+    return { fileName: entryPoint, outName: outFilePath, key: sm.key };
+  });
+  const exposes = Object.keys(config.exposes).map((key) => {
+    const entryPoint = config.exposes[key];
+    const outFilePath = key + '.js';
+    return { fileName: entryPoint, outName: outFilePath, key };
+  });
+
+  const entryPoints = [...shared, ...exposes];
+
+  const hash = !fedOptions.dev;
+
+  logger.info('Building federation artefacts');
+
+  const result = await bundle({
+    entryPoints,
+    outdir: fedOptions.outputPath,
+    tsConfigPath: fedOptions.tsConfig,
+    external: externals,
+    dev: !!fedOptions.dev,
+    watch: fedOptions.watch,
+    mappedPaths: config.sharedMappings,
+    kind: 'mapping-or-exposed',
+    hash,
+  });
+
+  const resultMap = createBuildResultMap(result, hash);
+
+  const sharedResult: Array<SharedInfo> = [];
+
+  for (const item of shared) {
+    sharedResult.push({
+      packageName: item.key,
+      outFileName: lookupInResultMap(resultMap, item.outName),
+      requiredVersion: '',
+      singleton: true,
+      strictVersion: false,
+      version: '',
+      dev: !fedOptions.dev
+        ? undefined
+        : {
+            entryPoint: path.normalize(item.fileName),
+          },
+    });
+  }
+
+  const exposedResult: Array<ExposesInfo> = [];
+
+  for (const item of exposes) {
+    exposedResult.push({
+      key: item.key,
+      outFileName: lookupInResultMap(resultMap, item.outName),
+      dev: !fedOptions.dev
+        ? undefined
+        : {
+            entryPoint: item.fileName,
+          },
+    });
+  }
+
+  return { mappings: sharedResult, exposes: exposedResult };
+}
+
+export function describeExposed(
+  config: NormalizedFederationConfig,
+  options: FederationOptions
+): Array<ExposesInfo> {
+  const result: Array<ExposesInfo> = [];
+
+  for (const key in config.exposes) {
+    const localPath = path.normalize(
+      path.join(options.workspaceRoot, config.exposes[key])
+    );
+
+    result.push({
+      key,
+      outFileName: '',
+      dev: !options.dev
+        ? undefined
+        : {
+            entryPoint: localPath,
+          },
+    });
+  }
+
+  return result;
+}
+
+export function describeSharedMappings(
+  config: NormalizedFederationConfig,
+  fedOptions: FederationOptions
+): Array<SharedInfo> {
+  const result: Array<SharedInfo> = [];
+
+  for (const m of config.sharedMappings) {
+    result.push({
+      packageName: m.key,
+      outFileName: '',
+      requiredVersion: '',
+      singleton: true,
+      strictVersion: false,
+      version: '',
+      dev: !fedOptions.dev
+        ? undefined
+        : {
+            entryPoint: path.normalize(m.path),
+          },
+    });
+  }
+
+  return result;
+}