@softarc/native-federation 4.1.3 → 4.2.0

package/dist/lib/config/share-utils.js

@@ -0,0 +1,344 @@
+import * as path from "path";
+import { cwd } from "process";
+import { DEFAULT_SKIP_LIST, isInSkipList, prepareSkipList } from "./default-skip-list.js";
+import {
+  sharedPackageJsonRepository,
+  findDepPackageJson,
+  getVersionMaps
+} from "../utils/package/package-info.js";
+import { getConfigContext } from "./configuration-context.js";
+import { logger } from "../utils/logger.js";
+import { nodeIo } from "../utils/io/node-io-adapter.js";
+import { resolvePackageJsonExportsWildcardCore } from "../utils/package/resolve-wildcard-keys.js";
+let inferVersion = false;
+function findRootTsConfigJson() {
+  return findRootTsConfigJsonCore(nodeIo);
+}
+function findRootTsConfigJsonCore(io) {
+  const packageJson = findPackageJson(io, cwd());
+  const projectRoot = path.dirname(packageJson);
+  const tsConfigBaseJson = path.join(projectRoot, "tsconfig.base.json");
+  const tsConfigJson = path.join(projectRoot, "tsconfig.json");
+  if (io.exists(tsConfigBaseJson)) {
+    return tsConfigBaseJson;
+  } else if (io.exists(tsConfigJson)) {
+    return tsConfigJson;
+  }
+  throw new Error("Neither a tsconfig.json nor a tsconfig.base.json was found");
+}
+function findPackageJson(io, folder) {
+  while (!io.exists(path.join(folder, "package.json")) && path.dirname(folder) !== folder) {
+    folder = path.dirname(folder);
+  }
+  const filePath = path.join(folder, "package.json");
+  if (io.exists(filePath)) {
+    return filePath;
+  }
+  throw new Error(
+    "no package.json found. Searched the following folder and all parents: " + folder
+  );
+}
+function lookupVersion(key, workspaceRoot, repo) {
+  const versionMaps = getVersionMaps(workspaceRoot, workspaceRoot, repo);
+  for (const versionMap of versionMaps) {
+    const version = lookupVersionInMap(key, versionMap);
+    if (version) {
+      return version;
+    }
+  }
+  throw new Error(
+    `Shared Dependency ${key} has requiredVersion:'auto'. However, this dependency is not found in your package.json`
+  );
+}
+function lookupVersionInMap(key, versions) {
+  const parts = key.split("/");
+  if (parts.length >= 2 && parts[0].startsWith("@")) {
+    key = parts[0] + "/" + parts[1];
+  } else {
+    key = parts[0];
+  }
+  if (!versions[key]) {
+    return null;
+  }
+  return versions[key];
+}
+function _findSecondaries(io, libPath, excludes, shareObject, acc, preparedSkipList) {
+  const files = io.readDir(libPath);
+  const secondaries = files.map((f) => path.join(libPath, f)).filter((f) => io.isDirectory(f) && !f.endsWith("node_modules"));
+  for (const s of secondaries) {
+    if (io.exists(path.join(s, "package.json"))) {
+      const secondaryLibName = s.replace(/\\/g, "/").replace(/^.*node_modules[/]/, "");
+      const inCustomSkipList = excludes.some(
+        (e) => e === secondaryLibName || e.endsWith("*") && secondaryLibName.startsWith(e.slice(0, -1))
+      );
+      if (inCustomSkipList) continue;
+      if (isInSkipList(secondaryLibName, preparedSkipList)) {
+        continue;
+      }
+      acc[secondaryLibName] = { ...shareObject };
+    }
+    _findSecondaries(io, s, excludes, shareObject, acc, preparedSkipList);
+  }
+}
+function findSecondaries(io, libPath, excludes, shareObject, preparedSkipList) {
+  const acc = {};
+  _findSecondaries(io, libPath, excludes, shareObject, acc, preparedSkipList);
+  return acc;
+}
+function getSecondaries(io, includeSecondaries, libPath, key, shareObject, preparedSkipList) {
+  let exclude = [];
+  let resolveGlob = false;
+  if (typeof includeSecondaries === "object") {
+    if (includeSecondaries.skip) {
+      if (Array.isArray(includeSecondaries.skip)) {
+        exclude = includeSecondaries.skip;
+      } else if (typeof includeSecondaries.skip === "string") {
+        exclude = [includeSecondaries.skip];
+      }
+    }
+    resolveGlob = !!includeSecondaries.resolveGlob;
+  }
+  if (!io.exists(libPath)) {
+    return {};
+  }
+  const configured = readConfiguredSecondaries(
+    io,
+    key,
+    libPath,
+    exclude,
+    shareObject,
+    preparedSkipList,
+    resolveGlob
+  );
+  if (configured) {
+    return configured;
+  }
+  const secondaries = findSecondaries(io, libPath, exclude, shareObject, preparedSkipList);
+  return secondaries;
+}
+function readConfiguredSecondaries(io, parent, libPath, exclude, shareObject, preparedSkipList, resolveGlob) {
+  const libPackageJson = path.join(libPath, "package.json");
+  if (!io.exists(libPackageJson)) {
+    return null;
+  }
+  const packageJson = JSON.parse(io.readText(libPackageJson));
+  const version = packageJson["version"];
+  const esm = packageJson["type"] === "module";
+  const exports = packageJson["exports"];
+  if (!exports) {
+    return null;
+  }
+  const keys = Object.keys(exports).filter(
+    (key) => key !== "." && key !== "./package.json" && key.startsWith("./") && (exports[key]?.["default"] || exports[key]?.["import"] || typeof exports[key] === "string")
+  );
+  const result = {};
+  const discoveredFiles = /* @__PURE__ */ new Set();
+  for (const key of keys) {
+    const secondaryName = path.join(parent, key).replace(/\\/g, "/");
+    const inCustomSkipList = exclude.some(
+      (e) => e === secondaryName || e.endsWith("*") && secondaryName.startsWith(e.slice(0, -1))
+    );
+    if (inCustomSkipList) continue;
+    if (isInSkipList(secondaryName, preparedSkipList)) {
+      continue;
+    }
+    const entry = getDefaultEntry(exports, key);
+    if (typeof entry !== "string") {
+      console.log("No entry point found for " + secondaryName);
+      continue;
+    }
+    if (!key.includes("*") && !isJsFile(entry)) {
+      continue;
+    }
+    const items = resolveGlobSecondaries(
+      io,
+      key,
+      libPath,
+      parent,
+      secondaryName,
+      entry,
+      { discovered: discoveredFiles, skip: exclude },
+      resolveGlob
+    );
+    items.forEach((e) => discoveredFiles.add(typeof e === "string" ? e : e.value));
+    for (const item of items) {
+      if (typeof item === "object") {
+        result[item.key] = {
+          ...shareObject,
+          packageInfo: {
+            entryPoint: item.value,
+            version: shareObject.version ?? version,
+            esm
+          }
+        };
+      } else {
+        result[item] = {
+          ...shareObject
+        };
+      }
+    }
+  }
+  return result;
+}
+function resolveGlobSecondaries(io, key, libPath, parent, secondaryName, entry, excludes, resolveGlob) {
+  let items = [];
+  if (key.includes("*")) {
+    if (!resolveGlob) return items;
+    const expanded = resolvePackageJsonExportsWildcardCore(io, key, entry, libPath);
+    items = expanded.map((e) => ({
+      key: path.join(parent, e.key),
+      value: path.join(libPath, e.value)
+    })).filter((i) => {
+      if (!isJsFile(i.value)) {
+        return false;
+      }
+      if (excludes.skip.some(
+        (e) => e.endsWith("*") ? i.key.startsWith(e.slice(0, -1)) : e === i.key
+      )) {
+        return false;
+      }
+      if (excludes.discovered.has(i.value)) {
+        return false;
+      }
+      return true;
+    });
+  } else {
+    items = [secondaryName];
+  }
+  return items;
+}
+function isJsFile(file) {
+  return file.endsWith(".js") || file.endsWith(".mjs") || file.endsWith(".cjs");
+}
+function getDefaultEntry(exports, key) {
+  let entry = "";
+  if (typeof exports[key] === "string") {
+    entry = exports[key];
+  }
+  if (!entry) {
+    entry = exports[key]?.["default"];
+    if (typeof entry === "object") {
+      entry = entry["default"];
+    }
+  }
+  if (!entry) {
+    entry = exports[key]?.["import"];
+    if (typeof entry === "object") {
+      entry = entry["import"] ?? entry["default"];
+    }
+  }
+  if (!entry) {
+    entry = exports[key]?.["require"];
+    if (typeof entry === "object") {
+      entry = entry["require"] ?? entry["default"];
+    }
+  }
+  return entry;
+}
+function shareAll(config, opts = {}) {
+  return shareAllCore(nodeIo, config, opts);
+}
+function shareAllCore(io, config, opts = {}, repo = sharedPackageJsonRepository) {
+  const projectPath = inferProjectPath(opts.projectPath);
+  const versionMaps = getVersionMaps(projectPath, projectPath, repo);
+  const sharedExternals = {};
+  const skipList = opts.skipList ?? DEFAULT_SKIP_LIST;
+  for (const versions of versionMaps) {
+    for (const key in versions) {
+      if (isInSkipList(key, prepareSkipList(skipList))) {
+        continue;
+      }
+      if (!!opts.overrides && Object.keys(opts.overrides).some((o) => key.startsWith(o))) {
+        continue;
+      }
+      const inferVersion2 = !config.requiredVersion || config.requiredVersion === "auto";
+      const requiredVersion = inferVersion2 ? versions[key] : config.requiredVersion;
+      if (!sharedExternals[key]) {
+        sharedExternals[key] = { ...config, requiredVersion };
+      }
+    }
+  }
+  return {
+    ...shareCore(io, sharedExternals, opts.projectPath, skipList, repo),
+    ...!opts.overrides ? {} : shareCore(io, opts.overrides, opts.projectPath, skipList, repo)
+  };
+}
+function inferProjectPath(projectPath) {
+  if (!projectPath && getConfigContext().packageJson) {
+    projectPath = path.dirname(getConfigContext().packageJson || "");
+  }
+  if (!projectPath && getConfigContext().workspaceRoot) {
+    projectPath = getConfigContext().workspaceRoot || "";
+  }
+  if (!projectPath) {
+    projectPath = cwd();
+  }
+  return projectPath;
+}
+function setInferVersion(infer) {
+  inferVersion = infer;
+}
+function share(configuredShareObjects, projectPath = "", skipList = DEFAULT_SKIP_LIST) {
+  return shareCore(nodeIo, configuredShareObjects, projectPath, skipList);
+}
+function shareCore(io, configuredShareObjects, projectPath = "", skipList = DEFAULT_SKIP_LIST, repo = sharedPackageJsonRepository) {
+  projectPath = inferProjectPath(projectPath);
+  const packagePath = findPackageJson(io, projectPath);
+  const preparedSkipList = prepareSkipList(skipList);
+  const shareObjects = { ...configuredShareObjects };
+  const result = {};
+  let includeSecondaries;
+  for (const key in shareObjects) {
+    includeSecondaries = false;
+    const shareObject = shareObjects[key];
+    if (shareObject.requiredVersion === "auto" || inferVersion && typeof shareObject.requiredVersion === "undefined" || shareObject.requiredVersion?.length < 1) {
+      const version = lookupVersion(key, projectPath, repo);
+      shareObject.requiredVersion = version;
+      shareObject.version = version.replace(/^\D*/, "");
+    }
+    if (typeof shareObject.includeSecondaries === "undefined") {
+      shareObject.includeSecondaries = true;
+    }
+    if (shareObject.includeSecondaries) {
+      includeSecondaries = shareObject.includeSecondaries;
+      delete shareObject.includeSecondaries;
+      if (includeSecondaries?.keepAll) shareObject.includeSecondaries = true;
+    }
+    result[key] = shareObject;
+    if (includeSecondaries) {
+      const libPackageJson = findDepPackageJson(key, path.dirname(packagePath), repo);
+      if (!libPackageJson) {
+        logger.error("Could not find folder containing dep " + key);
+        continue;
+      }
+      const libPath = path.dirname(libPackageJson);
+      const secondaries = getSecondaries(
+        io,
+        includeSecondaries,
+        libPath,
+        key,
+        shareObject,
+        preparedSkipList
+      );
+      if (secondaries) {
+        addSecondaries(secondaries, result);
+      }
+    }
+  }
+  return result;
+}
+function addSecondaries(secondaries, result) {
+  for (const key in secondaries) {
+    result[key] = secondaries[key];
+  }
+}
+export {
+  findRootTsConfigJson,
+  findRootTsConfigJsonCore,
+  getSecondaries,
+  setInferVersion,
+  share,
+  shareAll,
+  shareAllCore,
+  shareCore
+};

package/dist/lib/config/with-native-federation.js

@@ -0,0 +1,80 @@
+import { getRawMappedPaths } from "./mapped-paths.js";
+import { shareAll, findRootTsConfigJson } from "./share-utils.js";
+import { isInSkipList, prepareSkipList } from "./default-skip-list.js";
+import { logger } from "../utils/logger.js";
+function withNativeFederation(config) {
+  const skip = prepareSkipList(config.skip ?? []);
+  const chunks = config.chunks ?? true;
+  const normalized = {
+    $type: "classic",
+    name: config.name ?? "",
+    exposes: normalizeExposes(config.exposes),
+    shared: normalizeShared(config, skip, chunks),
+    sharedMappings: removeSkippedMappings(config, skip),
+    chunks,
+    skip,
+    externals: config.externals ?? [],
+    features: {
+      mappingVersion: config.features?.mappingVersion ?? true,
+      ignoreUnusedDeps: config.features?.ignoreUnusedDeps ?? true,
+      denseChunking: config.features?.denseChunking ?? false,
+      integrityHashes: config.features?.integrityHashes ?? false
+    },
+    ...config.shareScope && { shareScope: config.shareScope }
+  };
+  return normalized;
+}
+function normalizeExposes(exposes) {
+  if (!exposes) return {};
+  return Object.fromEntries(
+    Object.entries(exposes).map(([key, value]) => [
+      key,
+      typeof value === "string" ? { file: value } : value
+    ])
+  );
+}
+function normalizeShared(config, skip, chunks) {
+  let result = {};
+  const shared = config.shared ?? shareAll({
+    singleton: true,
+    strictVersion: true,
+    requiredVersion: "auto",
+    platform: "browser"
+  });
+  result = Object.keys(shared).reduce((acc, cur) => {
+    const key = cur.replace(/\\/g, "/");
+    const sharedConfig = shared[cur];
+    if (!!sharedConfig.chunks && !sharedConfig.build && sharedConfig.chunks !== chunks) {
+      logger.warn(
+        `External '${cur}' has explicit chunk settings, consider switching build type to { build: 'package' }.`
+      );
+      sharedConfig.chunks = chunks;
+    }
+    const normalizedConfig = {
+      requiredVersion: sharedConfig.requiredVersion ?? "auto",
+      singleton: sharedConfig.singleton ?? false,
+      strictVersion: sharedConfig.strictVersion ?? false,
+      version: sharedConfig.version,
+      chunks: sharedConfig.chunks ?? chunks,
+      includeSecondaries: sharedConfig.includeSecondaries,
+      packageInfo: sharedConfig.packageInfo,
+      platform: sharedConfig.platform ?? config.platform ?? "browser",
+      build: sharedConfig.build ?? "default",
+      ...sharedConfig.shareScope && { shareScope: sharedConfig.shareScope }
+    };
+    return {
+      ...acc,
+      [key]: normalizedConfig
+    };
+  }, {});
+  result = Object.keys(result).filter((key) => !isInSkipList(key, skip)).reduce((acc, cur) => ({ ...acc, [cur]: result[cur] }), {});
+  return result;
+}
+function removeSkippedMappings(config, skipList) {
+  const rootTsConfigPath = findRootTsConfigJson();
+  const paths = getRawMappedPaths(rootTsConfigPath, config.sharedMappings);
+  return Object.entries(paths).filter(([, _import]) => !isInSkipList(_import, skipList)).reduce((acc, [_path, _import]) => ({ ...acc, [_path]: _import }), {});
+}
+export {
+  withNativeFederation
+};

package/{src/lib/core → dist/lib/core/build}/build-adapter.d.ts

@@ -1,3 +1,3 @@
-import type { NFBuildAdapter } from '../domain/core/build-adapter.contract.js';
+import type { NFBuildAdapter } from '../../domain/core/build-adapter.contract.js';
 export declare function setBuildAdapter(buildAdapter: NFBuildAdapter): void;
 export declare function getBuildAdapter(): NFBuildAdapter;

package/dist/lib/core/build/build-adapter.js

@@ -0,0 +1,16 @@
+import { logger } from "../../utils/logger.js";
+let _buildAdapter = null;
+function setBuildAdapter(buildAdapter) {
+  _buildAdapter = buildAdapter;
+}
+function getBuildAdapter() {
+  if (!_buildAdapter) {
+    logger.error("Please set a BuildAdapter!");
+    throw new Error("BuildAdapter not set");
+  }
+  return _buildAdapter;
+}
+export {
+  getBuildAdapter,
+  setBuildAdapter
+};

package/dist/lib/core/build/build-for-federation.d.ts

@@ -0,0 +1,4 @@
+import type { FederationInfo } from '../../domain/core/federation-info.contract.js';
+import type { NormalizedFederationOptions } from '../../domain/core/federation-options.contract.js';
+import type { NormalizedFederationConfig } from '../../domain/config/federation-config.contract.js';
+export declare function buildForFederation(config: NormalizedFederationConfig, fedOptions: NormalizedFederationOptions, externals: string[], signal?: AbortSignal): Promise<FederationInfo>;

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

@@ -0,0 +1,207 @@
+import {
+  bundleExposedAndMappings,
+  describeExposed,
+  describeSharedMappings
+} from "./bundle-exposed-and-mappings.js";
+import { bundleShared } from "./bundle-shared.js";
+import { writeFederationInfo } from "../output/write-federation-info.js";
+import { writeImportMap } from "../output/write-import-map.js";
+import { logger } from "../../utils/logger.js";
+import { normalizePackageName } from "../../utils/normalize.js";
+import { AbortedError } from "../../utils/errors.js";
+import { addExternalsToCache } from "../cache/federation-cache.js";
+import path from "path";
+async function buildForFederation(config, fedOptions, externals, signal) {
+  fedOptions.federationCache.cachePath = path.join(
+    fedOptions.federationCache.cachePath,
+    fedOptions.projectName
+  );
+  logger.info("Building federation artifacts");
+  logger.notice("Skip packages you don't want to share in your federation config");
+  const { sharedBrowser, sharedServer, separateBrowser, separateServer } = splitShared(
+    config.shared
+  );
+  if (Object.keys(sharedBrowser).length > 0) {
+    logger.info(`Bundling external npm packages with bundle type 'browser-shared'`);
+    const start2 = process.hrtime();
+    const sharedPackageInfoBrowser = await bundleShared(
+      sharedBrowser,
+      config,
+      fedOptions,
+      externals,
+      { platform: "browser", bundleName: "browser-shared", chunks: config.chunks }
+    );
+    logger.measure(start2, "Step 2.1) Bundling all shared browser externals");
+    addExternalsToCache(fedOptions.federationCache, sharedPackageInfoBrowser);
+    if (signal?.aborted) throw new AbortedError("[buildForFederation] After shared-browser bundle");
+  }
+  if (Object.keys(sharedServer).length > 0) {
+    logger.info(`Bundling external npm packages with bundle type 'server-shared'`);
+    const start2 = process.hrtime();
+    const sharedPackageInfoServer = await bundleShared(
+      sharedServer,
+      config,
+      fedOptions,
+      externals,
+      { platform: "node", bundleName: "node-shared", chunks: config.chunks }
+    );
+    logger.measure(start2, "Step 2.1) Bundling all shared node externals");
+    addExternalsToCache(fedOptions.federationCache, sharedPackageInfoServer);
+    if (signal?.aborted) throw new AbortedError("[buildForFederation] After shared-node bundle");
+  }
+  if (Object.keys(separateBrowser).length > 0) {
+    logger.info(`Bundling external npm packages with bundle type 'browser-separate'`);
+    const start2 = process.hrtime();
+    const separatePackageInfoBrowser = await bundleSeparatePackages(
+      separateBrowser,
+      externals,
+      config,
+      fedOptions,
+      { platform: "browser" }
+    );
+    logger.measure(start2, "Step 2.2) Bundling all separate browser external packages");
+    addExternalsToCache(fedOptions.federationCache, separatePackageInfoBrowser);
+    if (signal?.aborted)
+      throw new AbortedError("[buildForFederation] After separate-browser bundle");
+  }
+  if (Object.keys(separateServer).length > 0) {
+    logger.info(`Bundling external npm packages with bundle type 'node-separate'`);
+    const start2 = process.hrtime();
+    const separatePackageInfoServer = await bundleSeparatePackages(
+      separateServer,
+      externals,
+      config,
+      fedOptions,
+      { platform: "node" }
+    );
+    logger.measure(start2, "Step 2.2) Bundling all separate node external packages");
+    addExternalsToCache(fedOptions.federationCache, separatePackageInfoServer);
+  }
+  if (signal?.aborted) throw new AbortedError("[buildForFederation] After separate-node bundle");
+  const start = process.hrtime();
+  const artifactInfo = await bundleExposedAndMappings(
+    config,
+    fedOptions,
+    externals,
+    void 0,
+    signal
+  );
+  logger.measure(start, "Step 3) Bundling all internal libraries and exposed modules.");
+  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;
+  const sharedExternals = [...fedOptions.federationCache.externals, ...sharedMappingInfo];
+  if (config?.shareScope) {
+    Object.values(sharedExternals).forEach((external) => {
+      if (!external.shareScope) external.shareScope = config.shareScope;
+    });
+  }
+  const buildNotificationsEndpoint = fedOptions.buildNotifications?.enable && fedOptions.dev ? fedOptions.buildNotifications?.endpoint : void 0;
+  const federationInfo = {
+    name: config.name,
+    shared: sharedExternals,
+    exposes: exposedInfo,
+    buildNotificationsEndpoint
+  };
+  if (fedOptions.federationCache.chunks) {
+    federationInfo.chunks = fedOptions.federationCache.chunks;
+  }
+  if (artifactInfo?.chunks) {
+    federationInfo.chunks = { ...federationInfo.chunks ?? {}, ...artifactInfo?.chunks };
+  }
+  if (config.features.integrityHashes) {
+    federationInfo.integrity = {
+      ...fedOptions.federationCache.integrity ?? {},
+      ...artifactInfo?.integrity ?? {}
+    };
+  }
+  writeFederationInfo(federationInfo, fedOptions);
+  writeImportMap(fedOptions.federationCache, fedOptions, federationInfo.integrity);
+  return federationInfo;
+}
+function inferPackageFromSecondary(secondary) {
+  const parts = secondary.split("/");
+  if (secondary.startsWith("@") && parts.length >= 2) {
+    return parts[0] + "/" + parts[1];
+  }
+  return parts[0];
+}
+async function bundleSeparatePackages(separateBrowser, externals, config, fedOptions, buildOptions) {
+  const groupedByPackage = {};
+  for (const [key, shared] of Object.entries(separateBrowser)) {
+    const packageName = shared.build === "separate" ? key : inferPackageFromSecondary(key);
+    if (!groupedByPackage[packageName]) {
+      groupedByPackage[packageName] = {
+        chunks: shared.chunks,
+        entries: {}
+      };
+    }
+    groupedByPackage[packageName].entries[key] = shared;
+  }
+  const bundlePromises = Object.entries(groupedByPackage).map(
+    async ([packageName, packageConfig]) => {
+      return bundleShared(
+        packageConfig.entries,
+        config,
+        fedOptions,
+        externals.filter((e) => !e.startsWith(packageName)),
+        {
+          platform: buildOptions.platform,
+          chunks: packageConfig.chunks,
+          bundleName: `${buildOptions.platform}-${normalizePackageName(packageName)}`
+        }
+      );
+    }
+  );
+  const buildResults = await Promise.all(bundlePromises);
+  return buildResults.reduce(
+    (acc, r) => {
+      let chunks = acc.chunks;
+      if (r.chunks) {
+        chunks = { ...acc.chunks ?? {}, ...r.chunks };
+      }
+      let integrity = acc.integrity;
+      if (r.integrity) {
+        integrity = { ...acc.integrity ?? {}, ...r.integrity };
+      }
+      return {
+        externals: [...acc.externals, ...r.externals],
+        chunks,
+        integrity
+      };
+    },
+    { externals: [] }
+  );
+}
+function splitShared(shared) {
+  const sharedServer = {};
+  const sharedBrowser = {};
+  const separateBrowser = {};
+  const separateServer = {};
+  for (const key in shared) {
+    const obj = shared[key];
+    if (obj?.platform === "node") {
+      if (obj.build === "default") {
+        sharedServer[key] = obj;
+      } else {
+        separateServer[key] = obj;
+      }
+    } else if (obj?.platform === "browser") {
+      if (obj.build === "default") {
+        sharedBrowser[key] = obj;
+      } else {
+        separateBrowser[key] = obj;
+      }
+    }
+  }
+  return {
+    sharedBrowser,
+    sharedServer,
+    separateBrowser,
+    separateServer
+  };
+}
+export {
+  buildForFederation
+};

package/{src/lib/utils → dist/lib/core/build}/build-result-map.d.ts

@@ -1,4 +1,4 @@
-import type { NFBuildAdapterResult } from '../domain/core/build-adapter.contract.js';
+import type { NFBuildAdapterResult } from '../../domain/core/build-adapter.contract.js';
 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;