feat(managers): plan the runtime composition and resolve one runtime family

.changeset/managers-runtime-composition.md

@@ -0,0 +1,5 @@
+---
+'@module-federation/managers': minor
+---
+
+Add pure helpers that plan a composed federation runtime: `planComposition`, `resolveRuntimeFamily`, `selectMode`, `resolveImports`, `renderComposition`, and `checkFederationGraph`.

packages/managers/__tests__/planComposition.spec.ts

@@ -0,0 +1,68 @@
+import { planComposition } from '../src/composition/plan';
+
+describe('planComposition', () => {
+  it('keeps every handler on when no participant carries options', () => {
+    expect(
+      planComposition([{ kind: 'needs', needs: ['remotes'] }], 'universal'),
+    ).toEqual({
+      shared: true,
+      remote: true,
+      snapshot: true,
+      adapters: ['remotes', 'share-scope'],
+      platform: 'universal',
+    });
+  });
+
+  it('turns a handler off only when every options participant disables it', () => {
+    const plan = planComposition(
+      [
+        {
+          kind: 'options',
+          disable: { shared: true, snapshot: true },
+          needs: [],
+        },
+        { kind: 'options', disable: { shared: true }, needs: [] },
+        { kind: 'needs', needs: [] },
+      ],
+      'web',
+    );
+    expect(plan.shared).toBe(false);
+    expect(plan.remote).toBe(true);
+    expect(plan.snapshot).toBe(true);
+  });
+
+  it('ignores needs participants when voting', () => {
+    const plan = planComposition(
+      [
+        { kind: 'options', disable: { remote: true }, needs: ['container'] },
+        { kind: 'needs', needs: ['remotes'] },
+      ],
+      'node',
+    );
+    expect(plan.remote).toBe(false);
+    expect(plan.adapters).toEqual(['remotes', 'container', 'share-scope']);
+  });
+
+  it('drops snapshot when remote is off', () => {
+    const plan = planComposition(
+      [{ kind: 'options', disable: { remote: true }, needs: [] }],
+      'web',
+    );
+    expect(plan.snapshot).toBe(false);
+  });
+
+  it('closes remotes, consumes and container over share-scope in table order', () => {
+    expect(
+      planComposition(
+        [
+          {
+            kind: 'needs',
+            needs: ['container', 'consumes', 'remotes', 'consumes'],
+          },
+        ],
+        'web',
+      ).adapters,
+    ).toEqual(['remotes', 'consumes', 'container', 'share-scope']);
+    expect(planComposition([], 'web').adapters).toEqual([]);
+  });
+});

packages/managers/src/composition/plan.ts

@@ -0,0 +1,59 @@
+export const ADAPTERS = [
+  'remotes',
+  'consumes',
+  'container',
+  'share-scope',
+] as const;
+export type AdapterName = (typeof ADAPTERS)[number];
+
+const ADAPTER_REQUIRES: Record<AdapterName, readonly AdapterName[]> = {
+  remotes: ['share-scope'],
+  consumes: ['share-scope'],
+  container: ['share-scope'],
+  'share-scope': [],
+};
+
+export type CompositionPlatform = 'web' | 'node' | 'universal';
+
+type Handler = 'shared' | 'remote' | 'snapshot';
+
+export type Participant =
+  | {
+      kind: 'options';
+      disable: { [K in Handler]?: true };
+      needs: readonly AdapterName[];
+    }
+  | { kind: 'needs'; needs: readonly AdapterName[] };
+
+export interface CompositionPlan {
+  shared: boolean;
+  remote: boolean;
+  snapshot: boolean;
+  adapters: AdapterName[];
+  platform: CompositionPlatform;
+}
+
+export function planComposition(
+  participants: readonly Participant[],
+  platform: CompositionPlatform,
+): CompositionPlan {
+  const voters = participants.filter((p) => p.kind === 'options');
+  const off = (handler: Handler) =>
+    voters.length > 0 && voters.every((p) => p.disable[handler]);
+
+  const needed = new Set<AdapterName>();
+  const add = (name: AdapterName) => {
+    if (needed.has(name)) return;
+    needed.add(name);
+    ADAPTER_REQUIRES[name].forEach(add);
+  };
+  participants.forEach((p) => p.needs.forEach(add));
+
+  return {
+    shared: !off('shared'),
+    remote: !off('remote'),
+    snapshot: !off('remote') && !off('snapshot'),
+    adapters: ADAPTERS.filter((name) => needed.has(name)),
+    platform,
+  };
+}

packages/managers/src/index.ts

@@ -8,3 +8,11 @@ export { UNKNOWN_MODULE_NAME } from './constant';
 
 export * as utils from './utils';
 export * as types from './types';
+
+export { planComposition, ADAPTERS } from './composition/plan';
+export type {
+  AdapterName,
+  CompositionPlan,
+  CompositionPlatform,
+  Participant,
+} from './composition/plan';