module-federation-angular-adapter 0.2200.0

package/src/index.js

@@ -0,0 +1,132 @@
+// Phase 1 — orchestrator swap (M1.2/M1.3).
+// Runtime moved from `@softarc/native-federation-orchestrator` to
+// `@module-federation/runtime` (`createInstance` + `loadRemote`). The NF-shaped
+// public surface (`initFederation`/`loadRemoteModule`) is kept for adoption
+// familiarity; NF-only options (`shimMode`, `sse`, `cacheTag`) are dropped.
+// NB finding #6: MF-esbuild still shares modules via es-module-shims import maps,
+// so the loader is unchanged — only the registration/manifest API differs.
+// M3.5: the NF `@softarc/.../domain` re-export and the `Imports`/`Scopes`/`ImportMap`
+// import-map types are removed — this entry is now pure MF.
+import { createInstance, } from '@module-federation/runtime';
+/**
+ * Framework packages that MUST resolve to a single instance, or Angular trips
+ * `NG0203`. Registered as MF singletons (M0.2's mandated config).
+ *
+ * `requiredVersion: false` for now — the singleton is enforced but the version
+ * check is relaxed, because resolving the installed version (NF's
+ * `requiredVersion: 'auto'`) is a config-build-time concern owned by
+ * `withModuleFederation` in **M3.1**; once that lands it feeds concrete ranges
+ * here. The actual module sharing flows through es-module-shims import maps at
+ * runtime (finding #6) — this map only declares the singleton/version contract.
+ */
+export const DEFAULT_ANGULAR_SHARED = {
+    '@angular/core': { shareConfig: { singleton: true, strictVersion: true, requiredVersion: false } },
+    '@angular/common': { shareConfig: { singleton: true, strictVersion: true, requiredVersion: false } },
+    '@angular/common/http': { shareConfig: { singleton: true, strictVersion: true, requiredVersion: false } },
+    '@angular/router': { shareConfig: { singleton: true, strictVersion: true, requiredVersion: false } },
+    '@angular/platform-browser': { shareConfig: { singleton: true, strictVersion: true, requiredVersion: false } },
+    rxjs: { shareConfig: { singleton: true, strictVersion: true, requiredVersion: false } },
+    'zone.js': { shareConfig: { singleton: true, strictVersion: true, requiredVersion: false } },
+};
+function toRemotes(remotes) {
+    return Object.entries(remotes).map(([name, entry]) => ({ name, entry }));
+}
+/** Strip a leading `./` so `'./Component'` → `'Component'` for the MF id. */
+function exposedKey(exposedModule) {
+    return exposedModule.replace(/^\.\//, '');
+}
+function normalizeOptions(optionsOrRemoteName, exposedModule) {
+    if (typeof optionsOrRemoteName === 'string' && exposedModule) {
+        return { remoteName: optionsOrRemoteName, exposedModule };
+    }
+    if (typeof optionsOrRemoteName === 'object' && !exposedModule) {
+        return optionsOrRemoteName;
+    }
+    throw new Error('unexpected arguments: please pass options or a remoteName/exposedModule-pair');
+}
+function logClientError(error) {
+    if (typeof window !== 'undefined') {
+        console.error(error);
+    }
+}
+/**
+ * Derive a remote's name from its `mf-manifest.json` URL (the lazy path's entry
+ * must be the JSON manifest — its top-level `name`, per M0.4 — not `remoteEntry.js`).
+ */
+async function resolveRemoteNameFromEntry(remoteEntry) {
+    const res = await fetch(remoteEntry);
+    if (!res.ok) {
+        throw new Error(`Failed to fetch remote manifest at ${remoteEntry}: ${res.status} ${res.statusText}`);
+    }
+    const info = (await res.json());
+    if (!info.name) {
+        throw new Error(`manifest at ${remoteEntry} does not declare a 'name'`);
+    }
+    return info.name;
+}
+async function loadFromInstance(mf, optionsOrRemoteName, exposedModule) {
+    const options = normalizeOptions(optionsOrRemoteName, exposedModule);
+    const { fallback } = options;
+    try {
+        // Lazy path: a remote not declared at initFederation time. Resolve its name
+        // from the manifest if omitted, then register it before loading.
+        if (!options.remoteName && options.remoteEntry) {
+            options.remoteName = await resolveRemoteNameFromEntry(options.remoteEntry);
+        }
+        if (options.remoteEntry && options.remoteName) {
+            mf.registerRemotes([{ name: options.remoteName, entry: options.remoteEntry }], { force: true });
+        }
+        if (!options.remoteName) {
+            throw new Error('loadRemoteModule: pass remoteName, or a remoteEntry pointing at an mf-manifest.json that declares a name');
+        }
+        const id = `${options.remoteName}/${exposedKey(options.exposedModule)}`;
+        const module = await mf.loadRemote(id);
+        if (module === null) {
+            throw new Error(`loadRemote returned null for '${id}'`);
+        }
+        return module;
+    }
+    catch (err) {
+        if (fallback) {
+            logClientError('error loading remote module: ' +
+                (err instanceof Error ? err.message : String(err)));
+            return fallback;
+        }
+        throw err;
+    }
+}
+/**
+ * Initialise Module Federation for an Angular host.
+ *
+ * Unlike NF's promise-returning init, this is **synchronous** — MF's
+ * `createInstance` is sync and remotes load lazily on first `loadRemoteModule`.
+ *
+ * ```ts
+ * const { loadRemoteModule } = initFederation({ mfe1: 'http://localhost:4201/remoteEntry.js' });
+ * const m = await loadRemoteModule('mfe1', './Component');
+ * ```
+ *
+ * @param remotes - name → remoteEntry/manifest URL map. (A bare manifest-URL
+ *   string, like NF's `remotesOrManifestUrl`, is deferred to M1.7.)
+ * @param options - {@link InitFederationOptions}.
+ */
+export function initFederation(remotes = {}, options) {
+    if (typeof remotes === 'string') {
+        throw new Error('initFederation: passing a manifest URL string is not supported yet (M1.7); pass a { name: entryUrl } map');
+    }
+    const mf = createInstance({
+        name: options?.name ?? 'host',
+        remotes: toRemotes(remotes),
+        // Host `@angular/*` (+ rxjs/zone.js) singletons (M1.4); caller overrides win.
+        shared: { ...DEFAULT_ANGULAR_SHARED, ...options?.shared },
+        plugins: options?.runtimePlugins ?? [],
+        shareStrategy: 'loaded-first',
+    });
+    const instance = {
+        instance: mf,
+        loadRemoteModule(optionsOrRemoteName, exposedModule) {
+            return loadFromInstance(mf, optionsOrRemoteName, exposedModule);
+        },
+    };
+    return instance;
+}

package/src/internal.d.ts

@@ -0,0 +1,2 @@
+export { runBuilder } from './builders/build/builder.js';
+//# sourceMappingURL=internal.d.ts.map

package/src/internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../../src/internal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC"}

package/src/internal.js

@@ -0,0 +1 @@
+export { runBuilder } from './builders/build/builder.js';

package/src/schematics/appbuilder/schema.d.ts

@@ -0,0 +1,3 @@
+export interface MfSchematicSchema {
+  project: string;
+}

package/src/schematics/appbuilder/schema.json

@@ -0,0 +1,17 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "mf",
+  "title": "",
+  "type": "object",
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "The project to add module federation",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "Project name (press enter for default project)"
+    }
+  }
+}

package/src/schematics/appbuilder/schematic.d.ts

@@ -0,0 +1,5 @@
+import type { Rule, Tree } from '@angular-devkit/schematics';
+import type { MfSchematicSchema } from './schema.js';
+export default function remove(options: MfSchematicSchema): Rule;
+export declare function getWorkspaceFileName(tree: Tree): string;
+//# sourceMappingURL=schematic.d.ts.map

package/src/schematics/appbuilder/schematic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schematic.d.ts","sourceRoot":"","sources":["../../../../src/schematics/appbuilder/schematic.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,4BAA4B,CAAC;AAE7D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAcrD,MAAM,CAAC,OAAO,UAAU,MAAM,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI,CAS/D;AAsFD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAUvD"}

package/src/schematics/appbuilder/schematic.js

@@ -0,0 +1,80 @@
+import * as path from 'path';
+export default function remove(options) {
+    return async function (tree /*, context*/) {
+        const workspaceFileName = getWorkspaceFileName(tree);
+        const workspace = JSON.parse(tree.read(workspaceFileName).toString('utf8'));
+        const normalized = normalizeOptions(options, workspace);
+        updateWorkspaceConfig(tree, normalized, workspace, workspaceFileName);
+    };
+}
+function updateWorkspaceConfig(tree, options, workspace, workspaceFileName) {
+    const { projectConfig } = options;
+    if (!projectConfig?.architect?.build || !projectConfig?.architect?.serve) {
+        throw new Error(`The project doesn't have a build or serve target in angular.json!`);
+    }
+    if (projectConfig.architect.esbuild) {
+        projectConfig.architect.esbuild.builder = '@angular/build:application';
+        projectConfig.architect.esbuild.options.browser = projectConfig.architect.esbuild.options.main;
+        delete projectConfig.architect.esbuild.options.main;
+    }
+    if (projectConfig.architect['serve-original']) {
+        const target = projectConfig.architect['serve-original'];
+        if (target.configurations?.production) {
+            target.configurations.production.buildTarget =
+                target.configurations.production.buildTarget.replace(':build:', ':esbuild:');
+        }
+        if (target.configurations?.development) {
+            target.configurations.development.buildTarget =
+                target.configurations.development.buildTarget.replace(':build:', ':esbuild:');
+        }
+    }
+    if (projectConfig.architect.serve) {
+        const target = projectConfig.architect.serve;
+        target.options.target = target.options.target.replace(':esbuild:', ':serve-original:');
+        delete target.options.port;
+    }
+    tree.overwrite(workspaceFileName, JSON.stringify(workspace, null, '\t'));
+}
+function normalizeOptions(options, workspace) {
+    const projects = Object.keys(workspace.projects);
+    if (!options.project && projects.length === 0) {
+        throw new Error(`No default project found. Please specifiy a project name!`);
+    }
+    if (!options.project) {
+        console.log('Using first configured project as default project: ' + projects[0]);
+        options.project = projects[0];
+    }
+    const projectName = options.project;
+    const projectConfig = workspace.projects[projectName];
+    if (!projectConfig) {
+        throw new Error(`Project ${projectName} not found in angular.json.`);
+    }
+    const projectRoot = projectConfig.root?.replace(/\\/g, '/');
+    const projectSourceRoot = projectConfig.sourceRoot?.replace(/\\/g, '/');
+    const manifestPath = path
+        .join(projectRoot, 'src/assets/federation.manifest.json')
+        .replace(/\\/g, '/');
+    const main = projectConfig.architect.build.options.main;
+    if (!projectConfig.architect.build.options.polyfills) {
+        projectConfig.architect.build.options.polyfills = [];
+    }
+    const polyfills = projectConfig.architect.build.options.polyfills;
+    return {
+        polyfills,
+        projectName,
+        projectRoot,
+        projectSourceRoot,
+        manifestPath,
+        projectConfig,
+        main,
+    };
+}
+export function getWorkspaceFileName(tree) {
+    if (tree.exists('angular.json')) {
+        return 'angular.json';
+    }
+    if (tree.exists('workspace.json')) {
+        return 'workspace.json';
+    }
+    throw new Error("angular.json or workspace.json expected! Did you call this in your project's root?");
+}

package/src/schematics/init/files/federation.config.mjs__tmpl__

@@ -0,0 +1,35 @@
+import { withModuleFederation, shareAll } from 'module-federation-angular-adapter/config';
+
+export default withModuleFederation({
+  name: '<%=project%>',
+
+<% if (type === 'remote') { %>
+
+  exposes: {
+    './Component': './<%=appComponentPath%>',
+  },
+<% } %>
+  shared: {
+    ...shareAll({ singleton: true, strictVersion: true, requiredVersion: 'auto' }),
+
+    // Share all of @angular/core, including its secondary entry points, to
+    // prevent version mismatches across the federation.
+    '@angular/core': {
+      singleton: true,
+      strictVersion: true,
+      requiredVersion: 'auto',
+      includeSecondaries: true,
+    },
+  },
+
+  skip: [
+    'rxjs/ajax',
+    'rxjs/fetch',
+    'rxjs/testing',
+    'rxjs/webSocket',
+    // Add further packages you don't need at runtime
+  ],
+
+  // Please read our FAQ about sharing libs:
+  // https://shorturl.at/jmzH0
+});

package/src/schematics/init/schema.d.ts

@@ -0,0 +1,5 @@
+export interface NfSchematicSchema {
+  project: string;
+  port: string;
+  type: 'host' | 'dynamic-host' | 'remote';
+}

package/src/schematics/init/schema.json

@@ -0,0 +1,30 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "nf",
+  "title": "",
+  "type": "object",
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "The project to add native-federation federation",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "Project name (press enter for default project)"
+    },
+    "port": {
+      "type": "number",
+      "description": "The port to use for the federated module (remote, micro frontend, etc.)",
+      "$default": {
+        "$source": "argv",
+        "index": 1
+      }
+    },
+    "type": {
+      "enum": ["host", "dynamic-host", "remote"],
+      "type": "string",
+      "default": "remote"
+    }
+  }
+}

package/src/schematics/init/schematic.d.ts

@@ -0,0 +1,6 @@
+import { type Rule } from '@angular-devkit/schematics';
+import type { NfSchematicSchema } from './schema.js';
+export { updatePackageJson } from './steps/update-package-json.js';
+export { getWorkspaceFileName } from './steps/normalize-options.js';
+export default function config(options: NfSchematicSchema): Rule;
+//# sourceMappingURL=schematic.d.ts.map

package/src/schematics/init/schematic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schematic.d.ts","sourceRoot":"","sources":["../../../../src/schematics/init/schematic.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,IAAI,EAAO,MAAM,4BAA4B,CAAC;AACzE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAcrD,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAEpE,MAAM,CAAC,OAAO,UAAU,MAAM,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI,CAsD/D"}

package/src/schematics/init/schematic.js

@@ -0,0 +1,38 @@
+import { chain, noop, url } from '@angular-devkit/schematics';
+import * as path from 'path';
+import { normalizeOptions, getWorkspaceFileName, } from './steps/normalize-options.js';
+import { updatePolyfills } from './steps/update-polyfills.js';
+import { generateRemoteMap } from './steps/generate-remote-map.js';
+import { generateFederationConfig } from './steps/generate-federation-config.js';
+import { updateWorkspaceConfig } from './steps/update-workspace-config.js';
+import { addDependencies } from './steps/add-dependencies.js';
+import { makeMainAsync } from './steps/make-main-async.js';
+export { updatePackageJson } from './steps/update-package-json.js';
+export { getWorkspaceFileName } from './steps/normalize-options.js';
+export default function config(options) {
+    return async function (tree, context) {
+        const workspaceFileName = getWorkspaceFileName(tree);
+        const workspace = JSON.parse(tree.read(workspaceFileName)?.toString('utf8') ?? '{}');
+        const normalized = normalizeOptions(options, workspace, tree);
+        const { polyfills, projectName, projectRoot, projectSourceRoot, manifestPath, manifestRelPath, main, } = normalized;
+        updatePolyfills(tree, polyfills);
+        const remoteMap = await generateRemoteMap(workspace, projectName);
+        if (options.type === 'dynamic-host' && !tree.exists(manifestPath)) {
+            tree.create(manifestPath, JSON.stringify(remoteMap, null, '\t'));
+        }
+        const federationConfigPath = path.join(projectRoot, 'federation.config.mjs');
+        const exists = tree.exists(federationConfigPath);
+        const cand1 = path.join(projectSourceRoot, 'app', 'app.component.ts').replace(/\\/g, '/');
+        const cand2 = path.join(projectSourceRoot, 'app', 'app.ts').replace(/\\/g, '/');
+        const appComponent = tree.exists(cand1) ? cand1 : tree.exists(cand2) ? cand2 : 'update-this.ts';
+        const generateRule = !exists
+            ? generateFederationConfig(url('./files'), remoteMap, projectRoot, projectSourceRoot, appComponent, options)
+            : noop;
+        updateWorkspaceConfig(tree, normalized, workspace, workspaceFileName);
+        addDependencies(tree, context);
+        return chain([
+            generateRule,
+            makeMainAsync(main, options, remoteMap, manifestRelPath),
+        ]);
+    };
+}

package/src/schematics/init/steps/add-dependencies.d.ts

@@ -0,0 +1,3 @@
+import type { SchematicContext, Tree } from '@angular-devkit/schematics';
+export declare function addDependencies(tree: Tree, context: SchematicContext): void;
+//# sourceMappingURL=add-dependencies.d.ts.map

package/src/schematics/init/steps/add-dependencies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-dependencies.d.ts","sourceRoot":"","sources":["../../../../../src/schematics/init/steps/add-dependencies.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,IAAI,EAAE,MAAM,4BAA4B,CAAC;AAoBzE,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,gBAAgB,GAAG,IAAI,CAW3E"}

package/src/schematics/init/steps/add-dependencies.js

@@ -0,0 +1,25 @@
+import { NodePackageInstallTask } from '@angular-devkit/schematics/tasks/index.js';
+import { addPackageJsonDependency, NodeDependencyType, } from '@schematics/angular/utility/dependencies';
+// Runtime dependencies a consuming app needs for Module Federation v2. Pinned to
+// the same versions the adapter is built against to avoid runtime version skew.
+const RUNTIME_DEPENDENCIES = [
+    // The MF-esbuild container shares modules via es-module-shims import maps
+    // (loaded on the page through the polyfills).
+    { name: 'es-module-shims', version: '^2.8.0' },
+    { name: '@module-federation/runtime', version: '2.6.0' },
+    { name: '@module-federation/sdk', version: '2.6.0' },
+    // Imported by the generated container as a bare specifier resolved from the
+    // app's node_modules — undeclared upstream, so it must be listed explicitly.
+    { name: '@module-federation/webpack-bundler-runtime', version: '2.6.0' },
+];
+export function addDependencies(tree, context) {
+    for (const dep of RUNTIME_DEPENDENCIES) {
+        addPackageJsonDependency(tree, {
+            name: dep.name,
+            type: NodeDependencyType.Default,
+            version: dep.version,
+            overwrite: false,
+        });
+    }
+    context.addTask(new NodePackageInstallTask());
+}

package/src/schematics/init/steps/generate-federation-config.d.ts

@@ -0,0 +1,4 @@
+import { type Source } from '@angular-devkit/schematics';
+import type { NfSchematicSchema } from '../schema.js';
+export declare function generateFederationConfig(templateSource: Source, remoteMap: Record<string, string>, projectRoot: string, projectSourceRoot: string, appComponentPath: string, options: NfSchematicSchema): import("@angular-devkit/schematics").Rule;
+//# sourceMappingURL=generate-federation-config.d.ts.map

package/src/schematics/init/steps/generate-federation-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-federation-config.d.ts","sourceRoot":"","sources":["../../../../../src/schematics/init/steps/generate-federation-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0B,KAAK,MAAM,EAAY,MAAM,4BAA4B,CAAC;AAC3F,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEtD,wBAAgB,wBAAwB,CACtC,cAAc,EAAE,MAAM,EACtB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EACjC,WAAW,EAAE,MAAM,EACnB,iBAAiB,EAAE,MAAM,EACzB,gBAAgB,EAAE,MAAM,EACxB,OAAO,EAAE,iBAAiB,6CAe3B"}

package/src/schematics/init/steps/generate-federation-config.js

@@ -0,0 +1,15 @@
+import { apply, mergeWith, move, template } from '@angular-devkit/schematics';
+export function generateFederationConfig(templateSource, remoteMap, projectRoot, projectSourceRoot, appComponentPath, options) {
+    const applied = apply(templateSource, [
+        template({
+            projectRoot,
+            projectSourceRoot,
+            appComponentPath,
+            remoteMap,
+            ...options,
+            tmpl: '',
+        }),
+        move(projectRoot),
+    ]);
+    return mergeWith(applied);
+}

package/src/schematics/init/steps/generate-remote-map.d.ts

@@ -0,0 +1,2 @@
+export declare function generateRemoteMap(workspace: any, projectName: string): Record<string, string>;
+//# sourceMappingURL=generate-remote-map.d.ts.map

package/src/schematics/init/steps/generate-remote-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-remote-map.d.ts","sourceRoot":"","sources":["../../../../../src/schematics/init/steps/generate-remote-map.ts"],"names":[],"mappings":"AAEA,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,0BAwBpE"}

package/src/schematics/init/steps/generate-remote-map.js

@@ -0,0 +1,20 @@
+import { strings } from '@angular-devkit/core';
+export function generateRemoteMap(workspace, projectName) {
+    const result = {};
+    for (const p in workspace.projects) {
+        const project = workspace.projects[p];
+        const projectType = project.projectType ?? 'application';
+        if (p !== projectName &&
+            projectType === 'application' &&
+            project?.architect?.serve &&
+            project?.architect?.build) {
+            const pPort = project.architect['serve-original']?.options?.port ??
+                project.architect.serve?.options?.port ??
+                4200;
+            result[strings.camelize(p)] = `http://localhost:${pPort}/remoteEntry.json`;
+        }
+    }
+    // No sibling projects → emit an empty map for the user to fill in, rather than
+    // injecting a surprising fake `mfe1` remote.
+    return result;
+}

package/src/schematics/init/steps/make-main-async.d.ts

@@ -0,0 +1,4 @@
+import type { Rule } from "@angular-devkit/schematics";
+import type { NfSchematicSchema } from "../schema.js";
+export declare function makeMainAsync(main: string, options: NfSchematicSchema, remoteMap: unknown, manifestRelPath: string): Rule;
+//# sourceMappingURL=make-main-async.d.ts.map

package/src/schematics/init/steps/make-main-async.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"make-main-async.d.ts","sourceRoot":"","sources":["../../../../../src/schematics/init/steps/make-main-async.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,4BAA4B,CAAC;AACvD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAsBtD,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,iBAAiB,EAC1B,SAAS,EAAE,OAAO,EAClB,eAAe,EAAE,MAAM,GACtB,IAAI,CA0BN"}

package/src/schematics/init/steps/make-main-async.js

@@ -0,0 +1,35 @@
+import * as path from "path";
+// The adapter's `initFederation` wrapper hides shimMode/logger/storage, so
+// generated apps don't ship internal orchestrator options or `logLevel: 'debug'`.
+const FEDERATION_IMPORT = `import { initFederation } from 'module-federation-angular-adapter';`;
+function getFederationArg(options, remoteMap, manifestRelPath) {
+    switch (options.type) {
+        case "dynamic-host":
+            return `'${manifestRelPath}'`;
+        case "host":
+            return JSON.stringify(remoteMap, null, 2).replace(/"/g, "'");
+        default:
+            return `{ '${options.project}': './remoteEntry.json' }`;
+    }
+}
+export function makeMainAsync(main, options, remoteMap, manifestRelPath) {
+    return async function (tree) {
+        const mainPath = path.dirname(main);
+        const bootstrapName = path.join(mainPath, "bootstrap.ts");
+        if (tree.exists(bootstrapName)) {
+            console.info(`${bootstrapName} already exists.`);
+            return;
+        }
+        const mainContent = tree.read(main);
+        if (mainContent)
+            tree.create(bootstrapName, mainContent);
+        const federationArg = getFederationArg(options, remoteMap, manifestRelPath);
+        tree.overwrite(main, `${FEDERATION_IMPORT}
+
+initFederation(${federationArg})
+  .catch(err => console.error(err))
+  .then(_ => import('./bootstrap'))
+  .catch(err => console.error(err));
+`);
+    };
+}

package/src/schematics/init/steps/normalize-options.d.ts

@@ -0,0 +1,20 @@
+import type { Tree } from '@angular-devkit/schematics';
+import type { NfSchematicSchema } from '../schema.js';
+export type NormalizedOptions = {
+    polyfills: string;
+    projectName: string;
+    projectRoot: string;
+    projectSourceRoot: string;
+    manifestPath: string;
+    manifestRelPath: string;
+    projectConfig: any;
+    main: string;
+    port: number;
+};
+export type PackageJson = {
+    dependencies: Record<string, string>;
+    scripts: Record<string, string>;
+};
+export declare function getWorkspaceFileName(tree: Tree): string;
+export declare function normalizeOptions(options: NfSchematicSchema, workspace: any, tree: Tree): NormalizedOptions;
+//# sourceMappingURL=normalize-options.d.ts.map

package/src/schematics/init/steps/normalize-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-options.d.ts","sourceRoot":"","sources":["../../../../../src/schematics/init/steps/normalize-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,4BAA4B,CAAC;AACvD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAGtD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,GAAG,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACjC,CAAC;AAEF,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAUvD;AAED,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,iBAAiB,EAC1B,SAAS,EAAE,GAAG,EACd,IAAI,EAAE,IAAI,GACT,iBAAiB,CAqEnB"}

package/src/schematics/init/steps/normalize-options.js

@@ -0,0 +1,64 @@
+import * as path from 'path';
+export function getWorkspaceFileName(tree) {
+    if (tree.exists('angular.json')) {
+        return 'angular.json';
+    }
+    if (tree.exists('workspace.json')) {
+        return 'workspace.json';
+    }
+    throw new Error("angular.json or workspace.json expected! Did you call this in your project's root?");
+}
+export function normalizeOptions(options, workspace, tree) {
+    const projects = Object.keys(workspace.projects);
+    if (!options.project && projects.length === 0) {
+        throw new Error(`No default project found. Please specifiy a project name!`);
+    }
+    if (!options.project) {
+        console.log('Using first configured project as default project: ' + projects[0]);
+        options.project = projects[0];
+    }
+    const projectName = options.project;
+    const projectConfig = workspace.projects[projectName];
+    if (!projectConfig) {
+        throw new Error(`Project ${projectName} not found in angular.json.`);
+    }
+    const projectRoot = projectConfig.root?.replace(/\\/g, '/');
+    const projectSourceRoot = projectConfig.sourceRoot?.replace(/\\/g, '/');
+    const publicPath = path.join(projectRoot, 'public').replace(/\\/g, '/');
+    let manifestPath = path.join(publicPath, 'federation.manifest.json').replace(/\\/g, '/');
+    let manifestRelPath = 'federation.manifest.json';
+    const hasPublicFolder = tree
+        .getDir(projectRoot)
+        .subdirs.map(p => String(p))
+        .includes('public');
+    if (!hasPublicFolder) {
+        manifestPath = path
+            .join(projectRoot, 'src/assets/federation.manifest.json')
+            .replace(/\\/g, '/');
+        manifestRelPath = 'assets/federation.manifest.json';
+    }
+    const main = projectConfig.architect.build.options.main ||
+        projectConfig.architect.build.options.browser ||
+        projectConfig.architect.esbuild.options.main || // fallback, if esbuild is already set
+        projectConfig.architect.esbuild.options.browser;
+    if (!projectConfig.architect.build.options.polyfills) {
+        projectConfig.architect.build.options.polyfills = [];
+    }
+    if (typeof projectConfig.architect.build.options.polyfills === 'string') {
+        projectConfig.architect.build.options.polyfills = [
+            projectConfig.architect.build.options.polyfills,
+        ];
+    }
+    const polyfills = projectConfig.architect.build.options.polyfills;
+    return {
+        polyfills,
+        projectName,
+        projectRoot,
+        projectSourceRoot,
+        manifestPath,
+        manifestRelPath,
+        projectConfig,
+        main,
+        port: +(options.port || 4200),
+    };
+}

package/src/schematics/init/steps/update-package-json.d.ts

@@ -0,0 +1,3 @@
+import type { Tree } from '@angular-devkit/schematics';
+export declare function updatePackageJson(tree: Tree): void;
+//# sourceMappingURL=update-package-json.d.ts.map

package/src/schematics/init/steps/update-package-json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-package-json.d.ts","sourceRoot":"","sources":["../../../../../src/schematics/init/steps/update-package-json.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,4BAA4B,CAAC;AAGvD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CA0BlD"}

package/src/schematics/init/steps/update-package-json.js

@@ -0,0 +1,19 @@
+export function updatePackageJson(tree) {
+    const packageJson = tree.readJson('package.json') ?? {};
+    const scriptCall = 'node node_modules/@angular-architects/native-federation/src/patch-angular-build.js';
+    if (!packageJson?.['scripts']) {
+        packageJson['scripts'] = {};
+    }
+    let postInstall = (packageJson['scripts']?.['postinstall'] || '');
+    if (!postInstall) {
+        return;
+    }
+    if (postInstall.includes(scriptCall)) {
+        postInstall = postInstall.replace(scriptCall, '');
+    }
+    if (postInstall.endsWith(' && ')) {
+        postInstall = postInstall.substring(0, postInstall.length - 4);
+    }
+    packageJson['scripts']['postinstall'] = postInstall;
+    tree.overwrite('package.json', JSON.stringify(packageJson, null, 2));
+}

package/src/schematics/init/steps/update-polyfills.d.ts

@@ -0,0 +1,3 @@
+import type { Tree } from '@angular-devkit/schematics';
+export declare function updatePolyfills(tree: Tree, polyfills: string | string[]): void;
+//# sourceMappingURL=update-polyfills.d.ts.map