@softarc/native-federation 4.1.2 → 4.2.0

package/dist/index.js

@@ -0,0 +1,21 @@
+import { setBuildAdapter } from "./lib/core/build/build-adapter.js";
+import { buildForFederation } from "./lib/core/build/build-for-federation.js";
+import { rebuildForFederation } from "./lib/core/build/rebuild-for-federation.js";
+import { createFederationCache } from "./lib/core/cache/federation-cache.js";
+import { bundleExposedAndMappings } from "./lib/core/build/bundle-exposed-and-mappings.js";
+import { getExternals } from "./lib/core/build/get-externals.js";
+import { normalizeFederationOptions } from "./lib/core/normalize-options.js";
+import { writeFederationInfo } from "./lib/core/output/write-federation-info.js";
+import { federationBuilder } from "./lib/core/federation-builder.js";
+export * from "./domain.js";
+export {
+  buildForFederation,
+  bundleExposedAndMappings,
+  createFederationCache,
+  federationBuilder,
+  getExternals,
+  normalizeFederationOptions,
+  rebuildForFederation,
+  setBuildAdapter,
+  writeFederationInfo
+};

package/{src → dist}/internal.d.ts

@@ -1,15 +1,14 @@
-export * from './lib/utils/build-result-map.js';
+export * from './lib/core/build/build-result-map.js';
 export { hashFile } from './lib/utils/hash-file.js';
 export * from './lib/utils/errors.js';
 export { logger, setLogLevel } from './lib/utils/logger.js';
 export type { PathToImport } from './lib/domain/utils/mapped-path.contract.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';
+export { RebuildQueue, type TrackResult } from './lib/core/rebuild-queue.js';
+export { writeImportMap } from './lib/core/output/write-import-map.js';
 export type { NormalizedExternalConfig, NormalizedSharedExternalsConfig, } from './lib/domain/config/external-config.contract.js';
 export type { NormalizedFederationConfig } from './lib/domain/config/federation-config.contract.js';
-export { getDefaultCachePath, getChecksum } from './lib/utils/cache-persistence.js';
+export { getDefaultCachePath, getChecksum } from './lib/core/cache/cache-persistence.js';
+export { isESMExport, type ExportCondition, type ExportEntry, } from './lib/utils/package/package-info.js';
 export { isInSkipList, prepareSkipList } from './lib/config/default-skip-list.js';
-export { NfFileWatcher, NfFileWatcherOptions } from './lib/domain/utils/file-watcher.contract.js';
+export type { NfFileWatcher, NfFileWatcherOptions } from './lib/domain/utils/file-watcher.contract.js';
 export { syncNfFileWatcher, createNfWatcher } from './lib/utils/file-watcher.js';

package/dist/internal.js

@@ -0,0 +1,26 @@
+export * from "./lib/core/build/build-result-map.js";
+import { hashFile } from "./lib/utils/hash-file.js";
+export * from "./lib/utils/errors.js";
+import { logger, setLogLevel } from "./lib/utils/logger.js";
+import { RebuildQueue } from "./lib/core/rebuild-queue.js";
+import { writeImportMap } from "./lib/core/output/write-import-map.js";
+import { getDefaultCachePath, getChecksum } from "./lib/core/cache/cache-persistence.js";
+import {
+  isESMExport
+} from "./lib/utils/package/package-info.js";
+import { isInSkipList, prepareSkipList } from "./lib/config/default-skip-list.js";
+import { syncNfFileWatcher, createNfWatcher } from "./lib/utils/file-watcher.js";
+export {
+  RebuildQueue,
+  createNfWatcher,
+  getChecksum,
+  getDefaultCachePath,
+  hashFile,
+  isESMExport,
+  isInSkipList,
+  logger,
+  prepareSkipList,
+  setLogLevel,
+  syncNfFileWatcher,
+  writeImportMap
+};

package/dist/lib/config/configuration-context.js

@@ -0,0 +1,15 @@
+let _context = {};
+function useWorkspace(workspaceRoot) {
+  _context = { ..._context, workspaceRoot };
+}
+function usePackageJson(packageJson) {
+  _context = { ..._context, packageJson };
+}
+function getConfigContext() {
+  return _context;
+}
+export {
+  getConfigContext,
+  usePackageJson,
+  useWorkspace
+};

package/dist/lib/config/default-skip-list.js

@@ -0,0 +1,36 @@
+const DEFAULT_SKIP_LIST = [
+  "@softarc/native-federation",
+  "@softarc/native-federation-core",
+  "@softarc/native-federation-node",
+  "@softarc/native-federation-esbuild",
+  "@softarc/native-federation-runtime",
+  "@softarc/native-federation-orchestrator",
+  "vanilla-native-federation",
+  "es-module-shims",
+  "tslib/",
+  (pkg) => pkg.startsWith("@types/")
+];
+function prepareSkipList(skipList) {
+  return {
+    strings: new Set(skipList.filter((e) => typeof e === "string")),
+    functions: skipList.filter((e) => typeof e === "function"),
+    regexps: skipList.filter((e) => typeof e === "object")
+  };
+}
+function isInSkipList(entry, skipList) {
+  if (skipList.strings.has(entry)) {
+    return true;
+  }
+  if (skipList.functions.find((f) => f(entry))) {
+    return true;
+  }
+  if (skipList.regexps.find((r) => r.test(entry))) {
+    return true;
+  }
+  return false;
+}
+export {
+  DEFAULT_SKIP_LIST,
+  isInSkipList,
+  prepareSkipList
+};

package/dist/lib/config/get-external-imports.d.ts

@@ -0,0 +1,2 @@
+import type { FileReaderPort } from '../domain/utils/io-port.contract.js';
+export declare function getExternalImportsCore(io: FileReaderPort, entryFilePath: string): string[];

package/dist/lib/config/get-external-imports.js

@@ -0,0 +1,60 @@
+import * as path from "path";
+import * as ts from "typescript";
+const RESOLVE_EXTENSIONS = [".ts", ".js", ".mjs", ".cjs"];
+function getExternalImportsCore(io, entryFilePath) {
+  const visited = /* @__PURE__ */ new Set();
+  const externals = /* @__PURE__ */ new Set();
+  function isExternal(specifier) {
+    return !specifier.startsWith(".") && !path.isAbsolute(specifier);
+  }
+  function resolveAsFileOrDirectory(p) {
+    const abs = path.resolve(p);
+    if (io.isFile(abs)) return abs;
+    for (const ext of RESOLVE_EXTENSIONS) {
+      if (io.isFile(abs + ext)) return abs + ext;
+    }
+    if (io.isDirectory(abs)) {
+      for (const file of RESOLVE_EXTENSIONS.map((e) => "index" + e)) {
+        const indexPath = path.join(abs, file);
+        if (io.isFile(indexPath)) return indexPath;
+      }
+    }
+    return null;
+  }
+  function handleSpecifier(spec, fromFile) {
+    if (isExternal(spec)) {
+      externals.add(spec);
+      return;
+    }
+    const resolvedPath = resolveAsFileOrDirectory(path.resolve(path.dirname(fromFile), spec));
+    if (resolvedPath) visit(resolvedPath);
+  }
+  function visit(filePath) {
+    const absPath = path.resolve(filePath);
+    if (visited.has(absPath)) return;
+    visited.add(absPath);
+    const resolvedFile = resolveAsFileOrDirectory(absPath);
+    if (!resolvedFile) return;
+    const fromFile = resolvedFile;
+    const source = io.readText(fromFile);
+    const sourceFile = ts.createSourceFile(fromFile, source, ts.ScriptTarget.Latest, true);
+    function walk(node) {
+      if (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) {
+        const moduleSpecifier = node.moduleSpecifier;
+        if (moduleSpecifier && ts.isStringLiteral(moduleSpecifier)) {
+          handleSpecifier(moduleSpecifier.text, fromFile);
+        }
+      }
+      if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.escapedText === "require" && node.arguments.length === 1 && ts.isStringLiteral(node.arguments[0])) {
+        handleSpecifier(node.arguments[0].text, fromFile);
+      }
+      ts.forEachChild(node, walk);
+    }
+    ts.forEachChild(sourceFile, walk);
+  }
+  visit(entryFilePath);
+  return Array.from(externals);
+}
+export {
+  getExternalImportsCore
+};

package/dist/lib/config/get-used-dependencies.d.ts

@@ -0,0 +1,24 @@
+import { type ProjectData } from '@softarc/sheriff-core';
+import { type PackageJsonRepository } from '../domain/utils/package-json.contract.js';
+import { type FileReaderPort } from '../domain/utils/io-port.contract.js';
+import { type PathToImport } from '../domain/utils/mapped-path.contract.js';
+import { type UsedDependencies } from '../domain/utils/used-dependencies.contract.js';
+import { type ExposeEntry } from '../domain/config/federation-config.contract.js';
+type GetProjectData = (entryPoint: string, cwd: string, options: {
+    includeExternalLibraries: boolean;
+}) => ProjectData;
+export interface UsedDependenciesDeps {
+    io: FileReaderPort;
+    repo: PackageJsonRepository;
+    getProjectData: GetProjectData;
+}
+type UsedDependenciesConfig = {
+    name?: string;
+    exposes?: Record<string, ExposeEntry>;
+    sharedMappings: PathToImport;
+};
+export declare function getUsedDependenciesFactory(workspaceRoot: string, fallbackEntryPoints?: string[]): (config: UsedDependenciesConfig) => UsedDependencies;
+export declare function getUsedDependenciesFactoryCore(deps: UsedDependenciesDeps, workspaceRoot: string, fallbackEntryPoints?: string[]): (config: UsedDependenciesConfig) => UsedDependencies;
+export declare function isSharedMapping(filePath: string, sharedMappings: PathToImport): boolean;
+export declare function matchMapping(filePath: string, sharedMappings: PathToImport): string | null;
+export {};

package/dist/lib/config/get-used-dependencies.js

@@ -0,0 +1,126 @@
+import { getProjectData as sheriffGetProjectData } from "@softarc/sheriff-core";
+import { cwd } from "process";
+import { sharedPackageJsonRepository, getPackageInfo } from "../utils/package/package-info.js";
+import { getExternalImportsCore } from "./get-external-imports.js";
+import { nodeIo } from "../utils/io/node-io-adapter.js";
+import { parseWildcard, substituteWildcard, toPosix } from "../utils/path-patterns.js";
+import * as path from "path";
+const defaultDeps = {
+  io: nodeIo,
+  repo: sharedPackageJsonRepository,
+  getProjectData: sheriffGetProjectData
+};
+function getUsedDependenciesFactory(workspaceRoot, fallbackEntryPoints) {
+  return getUsedDependenciesFactoryCore(defaultDeps, workspaceRoot, fallbackEntryPoints);
+}
+function getUsedDependenciesFactoryCore(deps, workspaceRoot, fallbackEntryPoints) {
+  return (config) => {
+    let entryPoints = Object.values(config.exposes ?? {}).map((e) => e.file);
+    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,
+        ...deps.getProjectData(entryPoint, cwd(), {
+          includeExternalLibraries: true
+        })
+      }),
+      {}
+    );
+    const usedPackageNames = /* @__PURE__ */ 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, deps),
+      internal: resolveUsedMappings(fileInfos, workspaceRoot, config.sharedMappings)
+    };
+  };
+}
+function addTransientDeps(packages, workspaceRoot, deps) {
+  const packagesAndPeers = /* @__PURE__ */ 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, deps.repo);
+    if (!pInfo) {
+      continue;
+    }
+    const peerDeps = getExternalImportsCore(deps.io, 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;
+    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 { prefix, hasWildcard } = parseWildcard(sharedPath);
+    if (hasWildcard) {
+      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 { prefix, suffix, hasWildcard } = parseWildcard(sharedPath);
+    if (hasWildcard) {
+      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 substituteWildcard(sharedImport, toImportPath(captured));
+    } else if (filePath === sharedPath || isIndexOf(filePath, sharedPath)) {
+      return sharedImport;
+    }
+  }
+  return null;
+}
+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 = toPosix(withoutExt);
+  return normalized.endsWith("/index") ? normalized.slice(0, -6) : normalized;
+}
+export {
+  getUsedDependenciesFactory,
+  getUsedDependenciesFactoryCore,
+  isSharedMapping,
+  matchMapping
+};

package/{src/lib/utils → dist/lib/config}/mapped-paths.d.ts

@@ -1,7 +1,7 @@
+import type { FileReaderPort } from '../domain/utils/io-port.contract.js';
 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;
+export declare function getRawMappedPathsCore(io: FileReaderPort, rootTsConfigPath: string, configuredSharedMappings?: string[], rootPath?: string): PathToImport;

package/dist/lib/config/mapped-paths.js

@@ -0,0 +1,31 @@
+import * as path from "path";
+import JSON5 from "json5";
+import { nodeIo } from "../utils/io/node-io-adapter.js";
+function getRawMappedPaths(rootTsConfigPath, configuredSharedMappings, rootPath) {
+  return getRawMappedPathsCore(nodeIo, rootTsConfigPath, configuredSharedMappings, rootPath);
+}
+function getRawMappedPathsCore(io, rootTsConfigPath, configuredSharedMappings, rootPath) {
+  const mappedPaths = {};
+  if (!path.isAbsolute(rootTsConfigPath)) {
+    throw new Error("SharedMappings.register: tsConfigPath needs to be an absolute path!");
+  }
+  const basePath = rootPath ?? path.normalize(path.dirname(rootTsConfigPath));
+  const shareAll = !configuredSharedMappings;
+  const sharedMappings = configuredSharedMappings ?? [];
+  const tsConfig = JSON5.parse(io.readText(rootTsConfigPath));
+  const mappings = tsConfig?.compilerOptions?.paths;
+  if (!mappings) {
+    return mappedPaths;
+  }
+  for (const key in mappings) {
+    const libPath = path.normalize(path.join(basePath, mappings[key][0]));
+    if (shareAll || sharedMappings.includes(key)) {
+      mappedPaths[libPath] = key;
+    }
+  }
+  return mappedPaths;
+}
+export {
+  getRawMappedPaths,
+  getRawMappedPathsCore
+};

package/dist/lib/config/remove-unused-deps.js

@@ -0,0 +1,11 @@
+function removeUnusedDeps(usedDependencies, config) {
+  const filteredDependencies = Object.entries(config.shared).filter(([shared, meta]) => !!meta.includeSecondaries || usedDependencies.external.has(shared)).reduce((acc, [shared, meta]) => ({ ...acc, [shared]: meta }), {});
+  return {
+    ...config,
+    shared: filteredDependencies,
+    sharedMappings: usedDependencies.internal
+  };
+}
+export {
+  removeUnusedDeps
+};

package/dist/lib/config/share-utils.d.ts

@@ -0,0 +1,20 @@
+import { type SkipList, type PreparedSkipList } from '../domain/config/skip-list.contract.js';
+import type { PackageJsonRepository } from '../domain/utils/package-json.contract.js';
+import type { FileReaderPort, GlobPort } from '../domain/utils/io-port.contract.js';
+import type { ExternalConfig, IncludeSecondariesOptions, ShareAllExternalsOptions, SharedExternalsConfig, ShareExternalsOptions } from '../domain/config/external-config.contract.js';
+export declare function findRootTsConfigJson(): string;
+export declare function findRootTsConfigJsonCore(io: FileReaderPort): string;
+export declare function getSecondaries(io: FileReaderPort & GlobPort, includeSecondaries: IncludeSecondariesOptions, libPath: string, key: string, shareObject: ExternalConfig, preparedSkipList: PreparedSkipList): SharedExternalsConfig | null;
+export declare function shareAll(config: ShareAllExternalsOptions, opts?: {
+    skipList?: SkipList;
+    projectPath?: string;
+    overrides?: ShareExternalsOptions;
+}): ShareExternalsOptions | null;
+export declare function shareAllCore(io: FileReaderPort & GlobPort, config: ShareAllExternalsOptions, opts?: {
+    skipList?: SkipList;
+    projectPath?: string;
+    overrides?: ShareExternalsOptions;
+}, repo?: PackageJsonRepository): ShareExternalsOptions | null;
+export declare function setInferVersion(infer: boolean): void;
+export declare function share(configuredShareObjects: ShareExternalsOptions, projectPath?: string, skipList?: SkipList): ShareExternalsOptions;
+export declare function shareCore(io: FileReaderPort & GlobPort, configuredShareObjects: ShareExternalsOptions, projectPath?: string, skipList?: SkipList, repo?: PackageJsonRepository): ShareExternalsOptions;