diff --git a/packages/angular/package.json b/packages/angular/package.json index 8057f32c..83b3b3d0 100644 --- a/packages/angular/package.json +++ b/packages/angular/package.json @@ -11,7 +11,7 @@ }, "peerDependencies": { "@softarc/native-federation": "^4.0.0", - "@softarc/native-federation-orchestrator": "^4.0.0", + "@softarc/native-federation-orchestrator": "^4.2.2", "@angular-devkit/architect": ">=0.2102.0", "@angular-devkit/build-angular": ">=21.2.0", "@angular-devkit/core": ">=21.2.0", @@ -19,7 +19,7 @@ }, "dependencies": { "@softarc/native-federation": "^4.0.0", - "@softarc/native-federation-orchestrator": "^4.0.0", + "@softarc/native-federation-orchestrator": "^4.2.2", "@angular-devkit/architect": "^0.2102.0", "@angular-devkit/build-angular": "^21.2.0", "@angular-devkit/core": "^21.2.0", diff --git a/packages/angular/src/builders/build/builder.ts b/packages/angular/src/builders/build/builder.ts index c231af59..e0bad0ab 100644 --- a/packages/angular/src/builders/build/builder.ts +++ b/packages/angular/src/builders/build/builder.ts @@ -40,7 +40,9 @@ import { } from '@softarc/native-federation/internal'; import { type Plugin, type PluginBuild } from 'esbuild'; import { existsSync, mkdirSync, rmSync } from 'fs'; -import { fstart } from '../../tools/fstart-as-data-url.js'; +import { federationServerEntry } from '../../tools/federation-server-entry.js'; +import { generateDevHostInstancesEntry } from '../../tools/dev-host-instances-entry.js'; +import { devHostInstancesPlugin } from '../../plugin/dev-host-instances-plugin.js'; import { createAngularBuildAdapter } from '../../utils/angular-esbuild-adapter.js'; import { getI18nConfig, translateFederationArtifacts } from '../../utils/i18n.js'; import { updateScriptTags } from '../../utils/update-index-html.js'; @@ -277,6 +279,22 @@ export async function* runBuilder( const isLocalDevelopment = runViteServer && nfBuilderOptions.dev; + // Dev SSR: inject a bootstrap that inits federation and bridges the host's + // singletons to remotes. The plugin self-gates on platform === 'node', so + // it's a no-op for CSR dev servers. (Prod SSR uses writeFederationServerEntry.) + if (isLocalDevelopment) { + // The bridge fetches the manifest over HTTP from the dev server's origin + // (Vite never writes it to disk under `ng serve`). + const devServerOrigin = getDevServerOrigin(serverOptions); + + plugins.push( + devHostInstancesPlugin( + generateDevHostInstancesEntry({ relBrowserPath: browserOutputPath, devServerOrigin }), + path.join(cachePath, 'nf-dev-host-instances.mjs') + ) + ); + } + // Initialize SSE reloader only for local development if (isLocalDevelopment && nfBuilderOptions.buildNotifications?.enable) { federationBuildNotifier.initialize(nfBuilderOptions.buildNotifications.endpoint); @@ -357,10 +375,6 @@ export async function* runBuilder( syncNfFileWatcher(nfWatcher, normalized.options.federationCache.bundlerCache); } - if (activateSsr) { - writeFstartScript(normalized.options); - } - const hasLocales = i18n?.locales && Object.keys(i18n.locales).length > 0; if (hasLocales && localeFilter) { const start = process.hrtime(); @@ -502,6 +516,12 @@ export async function* runBuilder( } first = false; } + + // Rewrite the emitted SSR entry (see writeFederationServerEntry). After the + // Angular build so the entry it produced exists on disk. + if (activateSsr && ngBuildStatus.success) { + writeFederationServerEntry(normalized.options); + } } finally { rebuildQueue.dispose(); await adapter.dispose(); @@ -527,12 +547,55 @@ function removeBaseHref(req: { url?: string }, baseHref?: string) { return url; } -function writeFstartScript(nfOptions: NormalizedFederationOptions) { +/** + * Rename the CLI's emitted `server.mjs` to `bootstrap-server.mjs` and write the + * Angular-free {@link federationServerEntry} in its place, so the node loader is + * registered before any `@angular/*` is evaluated. See that file for the why. + */ +function writeFederationServerEntry(nfOptions: NormalizedFederationOptions) { const serverOutpath = path.join(nfOptions.outputPath, '../server'); - const fstartPath = path.join(serverOutpath, 'fstart.mjs'); - const buffer = Buffer.from(fstart, 'base64'); - fs.mkdirSync(serverOutpath, { recursive: true }); - fs.writeFileSync(fstartPath, buffer, 'utf-8'); + const emittedEntry = path.join(serverOutpath, 'server.mjs'); + const bootstrapEntry = path.join(serverOutpath, 'bootstrap-server.mjs'); + + if (!fs.existsSync(emittedEntry)) { + logger.warn( + `SSR: expected '${emittedEntry}' was not found; skipping federation server entry. ` + + `Federated remotes may fail to render server-side.` + ); + return; + } + + fs.renameSync(emittedEntry, bootstrapEntry); + + // Preserve the source map (if any) and repoint its reference. + const emittedMap = `${emittedEntry}.map`; + if (fs.existsSync(emittedMap)) { + const bootstrapMap = `${bootstrapEntry}.map`; + fs.renameSync(emittedMap, bootstrapMap); + const bootstrapCode = fs + .readFileSync(bootstrapEntry, 'utf-8') + .replace(/sourceMappingURL=server\.mjs\.map/g, 'sourceMappingURL=bootstrap-server.mjs.map'); + fs.writeFileSync(bootstrapEntry, bootstrapCode, 'utf-8'); + } + + fs.writeFileSync(emittedEntry, federationServerEntry, 'utf-8'); +} + +/** + * Build the dev server's origin (e.g. `http://localhost:4200`) from the resolved + * dev-server options, whose `port` Angular's normalizeOptions already defaults. + * Omits the port when none is set, and returns undefined when there are no serve + * options at all, so the bridge falls back to the on-disk manifest path. + */ +function getDevServerOrigin( + serverOptions: { ssl?: boolean; host?: string; port?: number } | null +): string | undefined { + if (!serverOptions) { + return undefined; + } + const protocol = serverOptions.ssl ? 'https' : 'http'; + const host = serverOptions.host || 'localhost'; + return serverOptions.port ? `${protocol}://${host}:${serverOptions.port}` : `${protocol}://${host}`; } function getLocaleFilter(options: ApplicationBuilderOptions, runViteServer: boolean) { diff --git a/packages/angular/src/plugin/dev-host-instances-plugin.ts b/packages/angular/src/plugin/dev-host-instances-plugin.ts new file mode 100644 index 00000000..58f72c7d --- /dev/null +++ b/packages/angular/src/plugin/dev-host-instances-plugin.ts @@ -0,0 +1,41 @@ +import * as fs from 'fs'; +import * as path from 'path'; +import type { Plugin } from 'esbuild'; + +/** + * Injects the dev-only host-instance bootstrap (see + * `tools/dev-host-instances-entry.ts`) into the `ng serve` SSR server bundle. + * + * Gates on `platform === 'node'` — the only reliable SSR signal here, since the + * serve target carries no `ssr` flag. CSR dev servers are a no-op. + * + * `inject` makes the bootstrap run before the app. The orchestrator's Node entry + * is kept external so its `module.register()` loader hook fires; bundled, the + * bridge would silently never run. + * + * @param bootstrapSource generated bootstrap module source. + * @param bootstrapFilePath absolute path to write it to (`inject` needs a file). + */ +export function devHostInstancesPlugin(bootstrapSource: string, bootstrapFilePath: string): Plugin { + return { + name: 'nf-dev-host-instances', + setup(build) { + const options = build.initialOptions; + + if (options.platform !== 'node') { + return; + } + + fs.mkdirSync(path.dirname(bootstrapFilePath), { recursive: true }); + fs.writeFileSync(bootstrapFilePath, bootstrapSource, 'utf-8'); + + options.inject = [...(options.inject ?? []), bootstrapFilePath]; + + options.external = [ + ...(options.external ?? []), + '@softarc/native-federation-orchestrator/node', + '@softarc/native-federation-orchestrator', + ]; + }, + }; +} diff --git a/packages/angular/src/schematics/init/schematic.ts b/packages/angular/src/schematics/init/schematic.ts index 7d1b0391..8eb48217 100644 --- a/packages/angular/src/schematics/init/schematic.ts +++ b/packages/angular/src/schematics/init/schematic.ts @@ -15,6 +15,7 @@ import { updateWorkspaceConfig } from './steps/update-workspace-config.js'; import { addDependencies } from './steps/add-dependencies.js'; import { makeMainAsync } from './steps/make-main-async.js'; import { makeServerAsync } from './steps/make-server-async.js'; +import { setServerRenderMode } from './steps/set-server-render-mode.js'; import { generateTsConfig } from './steps/generate-tsconfig.js'; export { updatePackageJson, patchAngularBuild } from './steps/update-package-json.js'; @@ -77,7 +78,8 @@ export default function config(options: NfSchematicSchema): Rule { return chain([ generateRule, makeMainAsync(main, options, remoteMap, manifestRelPath), - ssr ? makeServerAsync(server, options, remoteMap) : noop(), + ssr ? makeServerAsync(server, options) : noop(), + ssr ? setServerRenderMode(projectSourceRoot) : noop(), ]); }; } diff --git a/packages/angular/src/schematics/init/steps/add-dependencies.ts b/packages/angular/src/schematics/init/steps/add-dependencies.ts index a5e62a71..85e4884b 100644 --- a/packages/angular/src/schematics/init/steps/add-dependencies.ts +++ b/packages/angular/src/schematics/init/steps/add-dependencies.ts @@ -6,8 +6,6 @@ import { NodeDependencyType, } from '@schematics/angular/utility/dependencies'; -const SSR_VERSION = '4.0.0-RC9'; - export function addDependencies(tree: Tree, context: SchematicContext, ssr: boolean): void { addPackageJsonDependency(tree, { name: '@angular-devkit/build-angular', @@ -23,15 +21,17 @@ export function addDependencies(tree: Tree, context: SchematicContext, ssr: bool overwrite: false, }); + // Browser-only projects bundle the orchestrator into the app, so a dev + // dependency suffices. For SSR it must be a runtime dependency: the generated + // server entry imports '@softarc/native-federation-orchestrator/node' as a + // bare specifier resolved from node_modules at runtime. addPackageJsonDependency(tree, { name: '@softarc/native-federation-orchestrator', - type: NodeDependencyType.Dev, - version: '^4.0.0', - overwrite: false, + type: ssr ? NodeDependencyType.Default : NodeDependencyType.Dev, + version: '^4.2.2', + overwrite: true, }); - context.addTask(new NodePackageInstallTask()); - if (ssr) { console.log('SSR detected ...'); console.log('Activating CORS ...'); @@ -42,12 +42,7 @@ export function addDependencies(tree: Tree, context: SchematicContext, ssr: bool version: '^2.8.5', overwrite: false, }); - - addPackageJsonDependency(tree, { - name: '@softarc/native-federation-node', - type: NodeDependencyType.Default, - version: SSR_VERSION, - overwrite: true, - }); } + + context.addTask(new NodePackageInstallTask()); } diff --git a/packages/angular/src/schematics/init/steps/make-server-async.ts b/packages/angular/src/schematics/init/steps/make-server-async.ts index 32175bde..4dde2ef8 100644 --- a/packages/angular/src/schematics/init/steps/make-server-async.ts +++ b/packages/angular/src/schematics/init/steps/make-server-async.ts @@ -1,89 +1,44 @@ import type { Rule, Tree } from '@angular-devkit/schematics'; import type { NfSchematicSchema } from '../schema.js'; -import * as path from 'path'; -export function makeServerAsync( - server: string, - options: NfSchematicSchema, - remoteMap: unknown -): Rule { +/** + * Prepare an SSR project's `server.ts` for federated SSR. Federation is *not* + * initialised here (the build's generated entry does that — see + * `tools/federation-server-entry.ts`); this step only: + * - enables CORS (remotes are served from other origins), and + * - makes the server listen when imported (not main) by honouring `pm_id`, + * which the generated entry sets. + */ +export function makeServerAsync(server: string, options: NfSchematicSchema): Rule { return async function (tree: Tree) { - const mainPath = path.dirname(server); - const bootstrapName = path.join(mainPath, 'bootstrap-server.ts'); + const content = tree.read(server)?.toString('utf8'); - if (tree.exists(bootstrapName)) { - console.info(`${bootstrapName} already exists.`); + if (!content) { + console.info(`${server} not found; skipping SSR server setup.`); return; } - const cors = `import { createRequire } from "module"; + if (content.includes("process.env['pm_id']")) { + console.info(`${server} already prepared for federated SSR.`); + return; + } + + const cors = `import { createRequire } from 'node:module'; const require = createRequire(import.meta.url); -const cors = require("cors"); +const cors = require('cors'); `; - const mainContent = tree.read(server)?.toString('utf8'); - const updatedContent = (cors + mainContent) + + const updatedContent = (cors + content) .replace( `const port = process.env['PORT'] || 4000`, `const port = process.env['PORT'] || ${options.port || 4000}` ) + .replace(`const app = express();`, `const app = express();\n app.use(cors());`) .replace( - `const app = express();`, - `const app = express();\n\tapp.use(cors());\n app.set('view engine', 'html');` - ) - .replace(`if (isMainModule(import.meta.url)) {`, ``) - .replace(/\}(?![\s\S]*\})/, ''); - - tree.create(bootstrapName, updatedContent); - - let newMainContent = ''; - if (options.type === 'dynamic-host') { - newMainContent = `import { initNodeFederation } from '@softarc/native-federation-node'; - -console.log('Starting SSR for Shell'); - -(async () => { - - await initNodeFederation({ - remotesOrManifestUrl: '../browser/federation.manifest.json', - relBundlePath: '../browser/', - }); - - await import('./bootstrap-server'); - -})(); -`; - } else if (options.type === 'host') { - const manifest = JSON.stringify(remoteMap, null, 2).replace(/"/g, "'"); - newMainContent = `import { initNodeFederation } from '@softarc/native-federation-node'; - -console.log('Starting SSR for Shell'); - -(async () => { - - await initNodeFederation({ - remotesOrManifestUrl: ${manifest}, - relBundlePath: '../browser/', - }); - - await import('./bootstrap-server'); - -})(); -`; - } else { - newMainContent = `import { initNodeFederation } from '@softarc/native-federation-node'; - -(async () => { - - await initNodeFederation({ - relBundlePath: '../browser/' - }); - - await import('./bootstrap-server'); - -})(); -`; - } + `if (isMainModule(import.meta.url)) {`, + `if (isMainModule(import.meta.url) || process.env['pm_id']) {` + ); - tree.overwrite(server, newMainContent); + tree.overwrite(server, updatedContent); }; } diff --git a/packages/angular/src/schematics/init/steps/set-server-render-mode.ts b/packages/angular/src/schematics/init/steps/set-server-render-mode.ts new file mode 100644 index 00000000..c5bef1b4 --- /dev/null +++ b/packages/angular/src/schematics/init/steps/set-server-render-mode.ts @@ -0,0 +1,27 @@ +import type { Rule, Tree } from '@angular-devkit/schematics'; +import * as path from 'path'; + +/** + * Switch the scaffolded `RenderMode.Prerender` to `Server` in + * `app.routes.server.ts`. A federated remote loads at runtime and can't be + * prerendered, so the catch-all route must render on the server. Idempotent. + */ +export function setServerRenderMode(projectSourceRoot: string): Rule { + return async function (tree: Tree) { + const routesPath = path + .join(projectSourceRoot, 'app', 'app.routes.server.ts') + .replace(/\\/g, '/'); + + const content = tree.read(routesPath)?.toString('utf8'); + if (!content) { + console.info(`${routesPath} not found; skipping render mode update.`); + return; + } + + if (!content.includes('RenderMode.Prerender')) { + return; + } + + tree.overwrite(routesPath, content.replace(/RenderMode\.Prerender/g, 'RenderMode.Server')); + }; +} diff --git a/packages/angular/src/schematics/init/steps/update-workspace-config.ts b/packages/angular/src/schematics/init/steps/update-workspace-config.ts index f1e35fbb..2ba33bcb 100644 --- a/packages/angular/src/schematics/init/steps/update-workspace-config.ts +++ b/packages/angular/src/schematics/init/steps/update-workspace-config.ts @@ -71,6 +71,18 @@ export function updateWorkspaceConfig( if (ssr) { projectConfig.architect.build.options.ssr = true; // projectConfig.architect.esbuild.options.prerender = false; + + // Angular scaffolds `security.allowedHosts: []`, which makes @angular/ssr + // reject the localhost Host header (SSRF guard) and silently fall back to + // CSR. Allow localhost so SSR actually renders during local development. + const esbuildOptions = projectConfig.architect.esbuild.options; + esbuildOptions.security ??= {}; + if ( + !Array.isArray(esbuildOptions.security.allowedHosts) || + esbuildOptions.security.allowedHosts.length === 0 + ) { + esbuildOptions.security.allowedHosts = ['localhost']; + } } const serve = projectConfig.architect.serve; diff --git a/packages/angular/src/tools/dev-host-instances-entry.ts b/packages/angular/src/tools/dev-host-instances-entry.ts new file mode 100644 index 00000000..7b363fc6 --- /dev/null +++ b/packages/angular/src/tools/dev-host-instances-entry.ts @@ -0,0 +1,105 @@ +/** + * Source of the dev-only SSR bootstrap injected into the `ng serve` server + * bundle (see `plugin/dev-host-instances-plugin.ts`). + * + * Under `ng serve` the host loads via Vite's SSR runner while remotes load via + * the orchestrator's Node loader — two `@angular/core` instances → NG0203. Fix: + * `hostInstances` publishes the host's singletons for remotes to re-use. We pass + * our own `load` so instances are captured in the host's realm, not the + * orchestrator's (they differ under Vite SSR). Prod dedupes via the import map. + */ +export interface DevHostInstancesOptions { + /** Browser output dir relative to the workspace root, e.g. `dist/host/browser`. */ + relBrowserPath: string; + /** + * Origin of the dev server, e.g. `http://localhost:4200`. Under `ng serve` the + * manifest lives only in Vite's memory, so it's fetched over HTTP from here. + * Omit for non-serve builds, where it's read from `relBrowserPath` on disk. + */ + devServerOrigin?: string; +} + +export function generateDevHostInstancesEntry({ + relBrowserPath, + devServerOrigin, +}: DevHostInstancesOptions): string { + // relBrowserPath is resolved against process.cwd() (the workspace root under + // `ng serve`), where the federation build writes its artifacts. + return `// Generated by @angular-architects/native-federation-v4 (dev SSR) — do not edit. +import { existsSync } from 'node:fs'; +import { join } from 'node:path'; + +const browserDir = join(process.cwd(), ${JSON.stringify(relBrowserPath)}); +const manifestPath = join(browserDir, 'federation.manifest.json'); +const devServerOrigin = ${JSON.stringify(devServerOrigin ?? null)}; + +// Vite serves the manifest and remote entries from memory under \`ng serve\`, +// so prefer the dev server's origin over the never-present on-disk path. +const hostRemoteEntry = devServerOrigin + ? devServerOrigin + '/remoteEntry.json' + : join(browserDir, 'remoteEntry.json'); + +// A static host returns 404 for the manifest — fetch it here so that 404 +// degrades to an empty manifest (which still bridges host singletons) instead +// of failing init. With no known origin, fall back to the on-disk path. +async function resolveManifest() { + if (devServerOrigin) { + try { + const res = await fetch(devServerOrigin + '/federation.manifest.json'); + if (res.ok) return await res.json(); + return {}; + } catch { + // Origin unreachable — fall through to the on-disk path. + } + } + return existsSync(manifestPath) ? manifestPath : {}; +} + +const g = globalThis; + +if (!g['__NF_HOST_SERVER_LOADER__']) { + const { initNodeFederation } = await import('@softarc/native-federation-orchestrator/node'); + + let loadRemoteModule; + let initError; + try { + ({ loadRemoteModule } = await initNodeFederation( + await resolveManifest(), + { + hostRemoteEntry, + // load through THIS module's graph so we capture the host's instances, + // not the orchestrator realm's (which differs under Vite SSR). + hostInstances: { load: (s) => import(/* @vite-ignore */ s) }, + }, + )); + } catch (err) { + initError = err; + } + + // Published iff the bridge actually ran. If not, fail fast — a missing bridge + // surfaces as an intermittent, hard-to-trace NG0203 instead. + const published = g['__NF_HOST_INSTANCES__']; + const bridged = published && Object.keys(published).length > 0; + if (!bridged) { + throw new Error( + '[native-federation] dev SSR host-instance bridge did not engage — ' + + 'globalThis.__NF_HOST_INSTANCES__ was not published. Usually ' + + "'@softarc/native-federation-orchestrator/node' was bundled by Vite " + + 'instead of externalized (so its module.register() loader never ran), ' + + 'or the installed orchestrator predates the hostInstances bridge.' + + (initError ? ' Cause: ' + (initError && initError.message || initError) : ''), + ); + } + + // Bridge ran but init failed (e.g. a remote is down): render without remotes. + if (initError) { + console.warn( + '[native-federation] dev SSR: federation init failed; rendering host without remotes:', + initError && initError.message || initError, + ); + } else { + g['__NF_HOST_SERVER_LOADER__'] = loadRemoteModule; + } +} +`; +} diff --git a/packages/angular/src/tools/federation-server-entry.ts b/packages/angular/src/tools/federation-server-entry.ts new file mode 100644 index 00000000..2846bbb7 --- /dev/null +++ b/packages/angular/src/tools/federation-server-entry.ts @@ -0,0 +1,60 @@ +/** + * Source of the Angular-free SSR entry the build emits as + * `dist//server/server.mjs`. + * + * The CLI prepends the `@angular/ssr` registration to its emitted entry, so the + * entry's *static* graph pulls in `@angular/*` — which ESM evaluates before the + * body runs, i.e. before `initNodeFederation()` could register the node loader. + * Result: two `@angular/core` instances (NG0203 / `JIT compilation failed`). + * + * Fix: the build renames the CLI's entry to `bootstrap-server.mjs` and writes + * this Angular-free entry as `server.mjs`. It registers the loader first, then + * dynamically imports the bootstrap — so every `@angular/*` resolves to the one + * shared federated chunk. + */ +export const federationServerEntry = `// Generated by @angular-architects/native-federation-v4 — do not edit. +// Angular-free entry: registers the federation node loader BEFORE any +// '@angular/*' module is evaluated, then hands off to the real server bundle. +import { initNodeFederation } from '@softarc/native-federation-orchestrator/node'; +import { existsSync } from 'node:fs'; +import { dirname, join } from 'node:path'; +import { fileURLToPath, pathToFileURL } from 'node:url'; + +const serverDir = dirname(fileURLToPath(import.meta.url)); +const browserDir = join(serverDir, '../browser'); + +// Static hosts have no manifest; an empty one still registers the host's shared +// externals via 'hostRemoteEntry', which is what dedupes '@angular/*'. +const manifestPath = join(browserDir, 'federation.manifest.json'); +const hostRemoteEntry = pathToFileURL(join(browserDir, 'remoteEntry.json')).href; + +try { + const { loadRemoteModule } = await initNodeFederation( + existsSync(manifestPath) ? manifestPath : {}, + { + hostRemoteEntry, + // Bridge the host's shared singletons (every '@angular/*' secondary, rxjs, + // zone.js, …) to remotes loaded during SSR. The loader is registered above + // before any '@angular/*' is evaluated, so the default '(s) => import(s)' + // resolves each specifier through the import map — the one shared chunk — + // and publishes it on globalThis.__NF_HOST_INSTANCES__. Without this the + // remote's '@angular/core/rxjs-interop' resolves a private build-internal + // chunk instead of the shared core instance → NG0203 (no injection context). + hostInstances: 'all', + }, + ); + // Bridge the loader to the app (read by the host's SSR render code). + globalThis['__NF_HOST_SERVER_LOADER__'] = loadRemoteModule; +} catch (err) { + console.warn( + '[native-federation] initNodeFederation failed; SSR will render without federated remotes:', + (err && err.message) || err, + ); +} + +// The bundle only listens when it's the main module or pm_id is set; it's now +// imported (not main), so opt it into listening. +process.env['pm_id'] ??= '1'; + +await import('./bootstrap-server.mjs'); +`; diff --git a/packages/angular/src/tools/fstart-as-data-url.ts b/packages/angular/src/tools/fstart-as-data-url.ts deleted file mode 100644 index 21d8317b..00000000 --- a/packages/angular/src/tools/fstart-as-data-url.ts +++ /dev/null @@ -1,2 +0,0 @@ -export const fstart = - '// libs/native-federation-node/src/lib/node/init-node-federation.ts
import { register } from "node:module";
import { pathToFileURL } from "node:url";
import * as fs2 from "node:fs/promises";
import * as path2 from "node:path";

// libs/native-federation-runtime/src/lib/model/global-cache.ts
var nfNamespace = "__NATIVE_FEDERATION__";
var global2 = globalThis;
global2[nfNamespace] ??= {
  externals: /* @__PURE__ */ new Map(),
  remoteNamesToRemote: /* @__PURE__ */ new Map(),
  baseUrlToRemoteNames: /* @__PURE__ */ new Map()
};
var globalCache = global2[nfNamespace];

// libs/native-federation-runtime/src/lib/model/externals.ts
var externals = globalCache.externals;
function getExternalKey(shared) {
  return `${shared.packageName}@${shared.version}`;
}
function getExternalUrl(shared) {
  const packageKey = getExternalKey(shared);
  return externals.get(packageKey);
}
function setExternalUrl(shared, url2) {
  const packageKey = getExternalKey(shared);
  externals.set(packageKey, url2);
}

// libs/native-federation-runtime/src/lib/model/import-map.ts
function mergeImportMaps(map1, map2) {
  return {
    imports: { ...map1.imports, ...map2.imports },
    scopes: { ...map1.scopes, ...map2.scopes }
  };
}

// libs/native-federation-runtime/src/lib/model/remotes.ts
var remoteNamesToRemote = globalCache.remoteNamesToRemote;
var baseUrlToRemoteNames = globalCache.baseUrlToRemoteNames;
function addRemote(remoteName, remote) {
  remoteNamesToRemote.set(remoteName, remote);
  baseUrlToRemoteNames.set(remote.baseUrl, remoteName);
}

// libs/native-federation-runtime/src/lib/utils/path-utils.ts
function getDirectory(url2) {
  const parts = url2.split("/");
  parts.pop();
  return parts.join("/");
}
function joinPaths(path1, path22) {
  while (path1.endsWith("/")) {
    path1 = path1.substring(0, path1.length - 1);
  }
  if (path22.startsWith("./")) {
    path22 = path22.substring(2, path22.length);
  }
  return `${path1}/${path22}`;
}

// libs/native-federation-runtime/src/lib/watch-federation-build.ts
function watchFederationBuildCompletion(endpoint) {
  const eventSource = new EventSource(endpoint);
  eventSource.onmessage = function(event) {
    const data = JSON.parse(event.data);
    if (data.type === "federation-rebuild-complete" /* COMPLETED */) {
      console.log("[Federation] Rebuild completed, reloading...");
      window.location.reload();
    }
  };
  eventSource.onerror = function(event) {
    console.warn("[Federation] SSE connection error:", event);
  };
}

// libs/native-federation-runtime/src/lib/init-federation.ts
async function processRemoteInfos(remotes, options = { throwIfRemoteNotFound: false }) {
  const processRemoteInfoPromises = Object.keys(remotes).map(
    async (remoteName) => {
      try {
        let url2 = remotes[remoteName];
        if (options.cacheTag) {
          const addAppend = remotes[remoteName].includes("?") ? "&" : "?";
          url2 += `${addAppend}t=${options.cacheTag}`;
        }
        return await processRemoteInfo(url2, remoteName);
      } catch (e) {
        const error = `Error loading remote entry for ${remoteName} from file ${remotes[remoteName]}`;
        if (options.throwIfRemoteNotFound) {
          throw new Error(error);
        }
        console.error(error);
        return null;
      }
    }
  );
  const remoteImportMaps = await Promise.all(processRemoteInfoPromises);
  const importMap = remoteImportMaps.reduce(
    (acc, remoteImportMap) => remoteImportMap ? mergeImportMaps(acc, remoteImportMap) : acc,
    { imports: {}, scopes: {} }
  );
  return importMap;
}
async function processRemoteInfo(federationInfoUrl, remoteName) {
  const baseUrl = getDirectory(federationInfoUrl);
  const remoteInfo = await loadFederationInfo(federationInfoUrl);
  if (!remoteName) {
    remoteName = remoteInfo.name;
  }
  if (remoteInfo.buildNotificationsEndpoint) {
    watchFederationBuildCompletion(
      baseUrl + remoteInfo.buildNotificationsEndpoint
    );
  }
  const importMap = createRemoteImportMap(remoteInfo, remoteName, baseUrl);
  addRemote(remoteName, { ...remoteInfo, baseUrl });
  return importMap;
}
function createRemoteImportMap(remoteInfo, remoteName, baseUrl) {
  const imports = processExposed(remoteInfo, remoteName, baseUrl);
  const scopes = processRemoteImports(remoteInfo, baseUrl);
  return { imports, scopes };
}
async function loadFederationInfo(url2) {
  const info = await fetch(url2).then((r) => r.json());
  return info;
}
function processRemoteImports(remoteInfo, baseUrl) {
  const scopes = {};
  const scopedImports = {};
  for (const shared of remoteInfo.shared) {
    const outFileName = getExternalUrl(shared) ?? joinPaths(baseUrl, shared.outFileName);
    setExternalUrl(shared, outFileName);
    scopedImports[shared.packageName] = outFileName;
  }
  scopes[baseUrl + "/"] = scopedImports;
  return scopes;
}
function processExposed(remoteInfo, remoteName, baseUrl) {
  const imports = {};
  for (const exposed of remoteInfo.exposes) {
    const key = joinPaths(remoteName, exposed.key);
    const value = joinPaths(baseUrl, exposed.outFileName);
    imports[key] = value;
  }
  return imports;
}
async function processHostInfo(hostInfo, relBundlesPath = "./") {
  const imports = hostInfo.shared.reduce(
    (acc, cur) => ({
      ...acc,
      [cur.packageName]: relBundlesPath + cur.outFileName
    }),
    {}
  );
  for (const shared of hostInfo.shared) {
    setExternalUrl(shared, relBundlesPath + shared.outFileName);
  }
  return { imports, scopes: {} };
}

// libs/native-federation-node/src/lib/utils/import-map-loader.js
import path from "path";
import url from "url";
import { promises as fs } from "fs";
var IMPORT_MAP_FILE_NAME = "node.importmap";
var baseURL = url.pathToFileURL(process.cwd()) + path.sep;
function resolveAndComposeImportMap(parsed) {
  if (!isPlainObject(parsed)) {
    throw Error(`Invalid import map - top level must be an object`);
  }
  let sortedAndNormalizedImports = {};
  if (Object.prototype.hasOwnProperty.call(parsed, "imports")) {
    if (!isPlainObject(parsed.imports)) {
      throw Error(`Invalid import map - "imports" property must be an object`);
    }
    sortedAndNormalizedImports = sortAndNormalizeSpecifierMap(
      parsed.imports,
      baseURL
    );
  }
  let sortedAndNormalizedScopes = {};
  if (Object.prototype.hasOwnProperty.call(parsed, "scopes")) {
    if (!isPlainObject(parsed.scopes)) {
      throw Error(`Invalid import map - "scopes" property must be an object`);
    }
    sortedAndNormalizedScopes = sortAndNormalizeScopes(parsed.scopes, baseURL);
  }
  const invalidKeys = Object.keys(parsed).filter(
    (key) => key !== "imports" && key !== "scopes"
  );
  if (invalidKeys.length > 0) {
    console.warn(
      `Invalid top-level key${invalidKeys.length > 0 ? "s" : ""} in import map - ${invalidKeys.join(", ")}`
    );
  }
  return {
    imports: sortedAndNormalizedImports,
    scopes: sortedAndNormalizedScopes
  };
}
function sortAndNormalizeSpecifierMap(map, baseURL2) {
  const normalized = {};
  for (let specifierKey in map) {
    const value = map[specifierKey];
    const normalizedSpecifierKey = normalizeSpecifierKey(specifierKey, baseURL2);
    if (normalizedSpecifierKey === null) {
      continue;
    }
    let addressURL = parseURLLikeSpecifier(value, baseURL2);
    if (addressURL === null) {
      console.warn(
        `Invalid URL address for import map specifier '${specifierKey}'`
      );
      normalized[normalizedSpecifierKey] = null;
      continue;
    }
    if (specifierKey.endsWith("/") && !addressURL.endsWith("/")) {
      console.warn(
        `Invalid URL address for import map specifier '${specifierKey}' - since the specifier ends in slash, so must the address`
      );
      normalized[normalizedSpecifierKey] = null;
      continue;
    }
    normalized[normalizedSpecifierKey] = addressURL;
  }
  return normalized;
}
function normalizeSpecifierKey(key) {
  if (key === "") {
    console.warn(`Specifier keys in import maps may not be the empty string`);
    return null;
  }
  return parseURLLikeSpecifier(key, baseURL) || key;
}
function parseURLLikeSpecifier(specifier, baseURL2) {
  const useBaseUrlAsParent = specifier.startsWith("/") || specifier.startsWith("./") || specifier.startsWith("../");
  try {
    return new URL(specifier, useBaseUrlAsParent ? baseURL2 : void 0).href;
  } catch {
    return null;
  }
}
function sortAndNormalizeScopes(map, baseURL2) {
  let normalized = {};
  for (let scopePrefix in map) {
    const potentialSpecifierMap = map[scopePrefix];
    if (!isPlainObject(potentialSpecifierMap)) {
      throw TypeError(
        `The value of scope ${scopePrefix} must be a JSON object`
      );
    }
    let scopePrefixURL;
    try {
      scopePrefixURL = new URL(scopePrefix, baseURL2).href;
    } catch {
      console.warn(
        `Scope prefix URL '${scopePrefix}' was not parseable in import map`
      );
      continue;
    }
    normalized[scopePrefixURL] = sortAndNormalizeSpecifierMap(
      potentialSpecifierMap,
      baseURL2
    );
  }
  return normalized;
}
function isPlainObject(obj) {
  return obj === Object(obj) && !Array.isArray(obj);
}
var importMapPromise = getImportMapPromise();
async function getImportMapPromise() {
  const relativePath = process.env.IMPORT_MAP_PATH || IMPORT_MAP_FILE_NAME;
  const importMapPath = path.resolve(process.cwd(), relativePath);
  let str;
  try {
    str = await fs.readFile(importMapPath);
  } catch (err) {
    return emptyMap();
  }
  let json;
  try {
    json = await JSON.parse(str);
  } catch (err) {
    throw Error(
      `Import map at ${importMapPath} contains invalid json: ${err.message}`
    );
  }
  return resolveAndComposeImportMap(json);
}
global.nodeLoader = global.nodeLoader || {};
global.nodeLoader.setImportMapPromise = function setImportMapPromise(promise) {
  importMapPromise = promise.then((map) => {
    return resolveAndComposeImportMap(map);
  });
};
function emptyMap() {
  return { imports: {}, scopes: {} };
}

// libs/native-federation-node/src/lib/utils/loader-as-data-url.js
var resolver = "import path from 'path';
import url from 'url';
import { promises as fs } from 'fs';

export const IMPORT_MAP_FILE_NAME = 'node.importmap';

const baseURL = url.pathToFileURL(process.cwd()) + path.sep;

// https://wicg.github.io/import-maps/#new-resolve-algorithm
export function resolveSpecifier(importMap, specifier, parentURL) {
  let currentBaseURL;
  if (parentURL) {
    const lastSlashIndex = parentURL.lastIndexOf(path.sep);
    currentBaseURL = parentURL.slice(0, lastSlashIndex + 1);
  } else {
    currentBaseURL = baseURL;
  }
  const normalizedSpecifier =
    parseURLLikeSpecifier(specifier, currentBaseURL) || specifier;
  for (let scopePrefix in importMap.scopes) {
    if (
      scopePrefix === currentBaseURL ||
      (scopePrefix.endsWith('/') && currentBaseURL.startsWith(scopePrefix))
    ) {
      const scopeImportsMatch = resolveImportsMatch(
        normalizedSpecifier,
        importMap.scopes[scopePrefix],
      );
      if (scopeImportsMatch) {
        return scopeImportsMatch;
      }
    } else {
      const topLevelImportsMatch = resolveImportsMatch(
        normalizedSpecifier,
        importMap.imports,
      );
      if (topLevelImportsMatch) {
        return topLevelImportsMatch;
      }
    }
  }

  return resolveImportsMatch(normalizedSpecifier, importMap.imports);
}

// https://wicg.github.io/import-maps/#resolve-an-imports-match
function resolveImportsMatch(normalizedSpecifier, specifierMap) {
  for (let specifierKey in specifierMap) {
    const resolutionResult = specifierMap[specifierKey];

    if (specifierKey === normalizedSpecifier) {
      if (resolutionResult === null) {
        throw TypeError(
          `The import map resolution of ${specifierKey} failed due to a null entry`,
        );
      }
      return resolutionResult;
    } else if (
      specifierKey.endsWith('/') &&
      normalizedSpecifier.startsWith(specifierKey)
    ) {
      if (resolutionResult === null) {
        throw TypeError(
          `The import map resolution of ${specifierKey} failed due to a null entry`,
        );
      }
      const afterPrefix = normalizedSpecifier.slice(specifierKey.length);
      try {
        return new URL(afterPrefix, resolutionResult).href;
      } catch {
        throw TypeError(
          `The import map resolution of ${specifierKey} failed due to URL parse failure`,
        );
      }
    }
  }

  return null;
}

// https://wicg.github.io/import-maps/#parsing
export function resolveAndComposeImportMap(parsed) {
  // Step 2
  if (!isPlainObject(parsed)) {
    throw Error(`Invalid import map - top level must be an object`);
  }

  // Step 3
  let sortedAndNormalizedImports = {};

  // Step 4
  if (Object.prototype.hasOwnProperty.call(parsed, 'imports')) {
    // Step 4.1
    if (!isPlainObject(parsed.imports)) {
      throw Error(`Invalid import map - "imports" property must be an object`);
    }

    // Step 4.2
    sortedAndNormalizedImports = sortAndNormalizeSpecifierMap(
      parsed.imports,
      baseURL,
    );
  }

  // Step 5
  let sortedAndNormalizedScopes = {};

  // Step 6
  if (Object.prototype.hasOwnProperty.call(parsed, 'scopes')) {
    // Step 6.1
    if (!isPlainObject(parsed.scopes)) {
      throw Error(`Invalid import map - "scopes" property must be an object`);
    }

    // Step 6.2
    sortedAndNormalizedScopes = sortAndNormalizeScopes(parsed.scopes, baseURL);
  }

  // Step 7
  const invalidKeys = Object.keys(parsed).filter(
    (key) => key !== 'imports' && key !== 'scopes',
  );
  if (invalidKeys.length > 0) {
    console.warn(
      `Invalid top-level key${
        invalidKeys.length > 0 ? 's' : ''
      } in import map - ${invalidKeys.join(', ')}`,
    );
  }

  // Step 8
  return {
    imports: sortedAndNormalizedImports,
    scopes: sortedAndNormalizedScopes,
  };
}

// https://wicg.github.io/import-maps/#sort-and-normalize-a-specifier-map
function sortAndNormalizeSpecifierMap(map, baseURL) {
  const normalized = {};

  for (let specifierKey in map) {
    const value = map[specifierKey];

    const normalizedSpecifierKey = normalizeSpecifierKey(specifierKey, baseURL);
    if (normalizedSpecifierKey === null) {
      continue;
    }

    let addressURL = parseURLLikeSpecifier(value, baseURL);
    if (addressURL === null) {
      console.warn(
        `Invalid URL address for import map specifier '${specifierKey}'`,
      );
      normalized[normalizedSpecifierKey] = null;
      continue;
    }

    if (specifierKey.endsWith('/') && !addressURL.endsWith('/')) {
      console.warn(
        `Invalid URL address for import map specifier '${specifierKey}' - since the specifier ends in slash, so must the address`,
      );
      normalized[normalizedSpecifierKey] = null;
      continue;
    }

    normalized[normalizedSpecifierKey] = addressURL;
  }

  return normalized;
}

// https://wicg.github.io/import-maps/#normalize-a-specifier-key
function normalizeSpecifierKey(key) {
  if (key === '') {
    console.warn(`Specifier keys in import maps may not be the empty string`);
    return null;
  }

  return parseURLLikeSpecifier(key, baseURL) || key;
}

// https://wicg.github.io/import-maps/#parse-a-url-like-import-specifier
function parseURLLikeSpecifier(specifier, baseURL) {
  const useBaseUrlAsParent =
    specifier.startsWith('/') ||
    specifier.startsWith('./') ||
    specifier.startsWith('../');

  try {
    return new URL(specifier, useBaseUrlAsParent ? baseURL : undefined).href;
  } catch {
    return null;
  }
}

// https://wicg.github.io/import-maps/#sort-and-normalize-scopes
function sortAndNormalizeScopes(map, baseURL) {
  let normalized = {};

  for (let scopePrefix in map) {
    const potentialSpecifierMap = map[scopePrefix];
    if (!isPlainObject(potentialSpecifierMap)) {
      throw TypeError(
        `The value of scope ${scopePrefix} must be a JSON object`,
      );
    }

    let scopePrefixURL;
    try {
      scopePrefixURL = new URL(scopePrefix, baseURL).href;
    } catch {
      console.warn(
        `Scope prefix URL '${scopePrefix}' was not parseable in import map`,
      );
      continue;
    }

    normalized[scopePrefixURL] = sortAndNormalizeSpecifierMap(
      potentialSpecifierMap,
      baseURL,
    );
  }

  return normalized;
}

function isPlainObject(obj) {
  return obj === Object(obj) && !Array.isArray(obj);
}

// ---

let importMapPromise = getImportMapPromise();

export async function resolve(specifier, context, defaultResolve) {
  const { parentURL = null } = context;
  const importMap = await importMapPromise;
  const importMapUrl = resolveSpecifier(importMap, specifier, parentURL);

  return defaultResolve(importMapUrl ?? specifier, context, defaultResolve);
}

export async function load(url, context, defaultLoad) {
  if (url.startsWith('http://') || url.startsWith('https://')) {
    const res = await fetch(url);
    if (!res.ok) {
      throw new Error(`Failed to fetch module from ${url}`);
    }
    const source = await res.text();
    return {
      shortCircuit: true,
      format: 'module',
      source,
    };
  }

  if (!url.startsWith('node:')) {
    context.format = 'module';
  }

  return defaultLoad(url, context, defaultLoad);
}

async function getImportMapPromise() {
  const relativePath = process.env.IMPORT_MAP_PATH || IMPORT_MAP_FILE_NAME;
  const importMapPath = path.resolve(process.cwd(), relativePath);

  let str;
  try {
    str = await fs.readFile(importMapPath);
  } catch (err) {
    return emptyMap();
  }

  let json;
  try {
    json = await JSON.parse(str);
  } catch (err) {
    throw Error(
      `Import map at ${importMapPath} contains invalid json: ${err.message}`,
    );
  }

  return resolveAndComposeImportMap(json);
}

global.nodeLoader = global.nodeLoader || {};

global.nodeLoader.setImportMapPromise = function setImportMapPromise(promise) {
  importMapPromise = promise.then((map) => {
    return resolveAndComposeImportMap(map);
  });
};

function emptyMap() {
  return { imports: {}, scopes: {} };
}
";

// libs/native-federation-node/src/lib/node/init-node-federation.ts
var defaultOptions = {
  remotesOrManifestUrl: {},
  relBundlePath: "../browser",
  throwIfRemoteNotFound: false
};
async function initNodeFederation(options) {
  const mergedOptions = { ...defaultOptions, ...options };
  const importMap = await createNodeImportMap(mergedOptions);
  await writeImportMap(importMap);
  await writeResolver();
  register(pathToFileURL("./federation-resolver.mjs").href);
}
async function createNodeImportMap(options) {
  const { remotesOrManifestUrl, relBundlePath } = options;
  const remotes = typeof remotesOrManifestUrl === "object" ? remotesOrManifestUrl : await loadFsManifest(remotesOrManifestUrl);
  const hostInfo = await loadFsFederationInfo(relBundlePath);
  const hostImportMap = await processHostInfo(hostInfo, "./" + relBundlePath);
  const remotesImportMap = await processRemoteInfos(remotes, {
    throwIfRemoteNotFound: options.throwIfRemoteNotFound,
    cacheTag: options.cacheTag
  });
  const importMap = mergeImportMaps(hostImportMap, remotesImportMap);
  return importMap;
}
async function loadFsManifest(manifestUrl) {
  const content = await fs2.readFile(manifestUrl, "utf-8");
  const manifest = JSON.parse(content);
  return manifest;
}
async function loadFsFederationInfo(relBundlePath) {
  const manifestPath = path2.join(relBundlePath, "remoteEntry.json");
  const content = await fs2.readFile(manifestPath, "utf-8");
  const manifest = JSON.parse(content);
  return manifest;
}
async function writeImportMap(map) {
  await fs2.writeFile(
    IMPORT_MAP_FILE_NAME,
    JSON.stringify(map, null, 2),
    "utf-8"
  );
}
async function writeResolver() {
  const buffer = Buffer.from(resolver, "base64");
  await fs2.writeFile("federation-resolver.mjs", buffer, "utf-8");
}

// libs/native-federation-node/src/lib/utils/fstart-args-parser.ts
import * as fs3 from "node:fs";
var defaultArgs = {
  entry: "./server.mjs",
  remotesOrManifestUrl: "../browser/federation.manifest.json",
  relBundlePath: "../browser/"
};
function parseFStartArgs() {
  const args2 = {
    entry: "",
    remotesOrManifestUrl: "",
    relBundlePath: ""
  };
  let key = "";
  for (let i = 2; i < process.argv.length; i++) {
    const cand = process.argv[i];
    if (cand.startsWith("--")) {
      const candKey = cand.substring(2);
      if (defaultArgs[candKey]) {
        key = candKey;
      } else {
        console.error(`switch ${cand} not supported!`);
        exitWithUsage(defaultArgs);
      }
    } else if (key) {
      args2[key] = cand;
      key = "";
    } else {
      console.error(`unreladed value ${cand}!`);
      exitWithUsage(defaultArgs);
    }
  }
  applyDefaultArgs(args2);
  return args2;
}
function applyDefaultArgs(args2) {
  if (args2.relBundlePath && !args2.remotesOrManifestUrl) {
    const cand = defaultArgs.relBundlePath + "federation.manifest.json";
    if (fs3.existsSync(cand)) {
      args2.remotesOrManifestUrl = cand;
    }
  }
  args2.entry = args2.entry || defaultArgs.entry;
  args2.relBundlePath = args2.relBundlePath || defaultArgs.relBundlePath;
  args2.remotesOrManifestUrl = args2.remotesOrManifestUrl || defaultArgs.remotesOrManifestUrl;
  if (!fs3.existsSync(args2.remotesOrManifestUrl)) {
    args2.remotesOrManifestUrl = void 0;
  }
}
function exitWithUsage(defaultArgs2) {
  let args2 = "";
  for (const key in defaultArgs2) {
    args2 += `[--${key} ${defaultArgs2[key]}] `;
  }
  console.log("usage: nfstart " + args2);
  process.exit(1);
}

// libs/native-federation-node/src/lib/utils/fstart.ts
var args = parseFStartArgs();
(async () => {
  await initNodeFederation({
    ...args.remotesOrManifestUrl ? { remotesOrManifestUrl: args.remotesOrManifestUrl } : {},
    relBundlePath: args.relBundlePath
  });
  await import(args.entry);
})();
'; diff --git a/packages/angular/src/utils/angular-bundler.ts b/packages/angular/src/utils/angular-bundler.ts index 78b1277c..8d3977af 100644 --- a/packages/angular/src/utils/angular-bundler.ts +++ b/packages/angular/src/utils/angular-bundler.ts @@ -163,7 +163,7 @@ export async function createAngularEsbuildContext(options: NormalizedContextOpti logLimit: 0, plugins: [compilerPlugin, commonjsPlugin(), ...customPlugins], define: { - ngDevMode: dev ? 'true' : 'false', + ...(dev ? {} : { ngDevMode: 'false' }), ngJitMode: 'false', }, ...(builderOptions.loader ? { loader: builderOptions.loader } : {}), diff --git a/packages/angular/src/utils/node-modules-bundler.ts b/packages/angular/src/utils/node-modules-bundler.ts index 8dc977a6..996d94f3 100644 --- a/packages/angular/src/utils/node-modules-bundler.ts +++ b/packages/angular/src/utils/node-modules-bundler.ts @@ -156,7 +156,7 @@ export async function createNodeModulesEsbuildContext(options: NormalizedContext ...customPlugins, ], define: { - ngDevMode: dev ? 'true' : 'false', + ...(dev ? {} : { ngDevMode: 'false' }), ngJitMode: 'false', }, ...(builderOptions.loader ? { loader: builderOptions.loader } : {}), diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index b5ee0fea..7b128448 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -169,8 +169,8 @@ importers: specifier: ^4.0.0 version: 4.1.3(typescript@5.9.3) '@softarc/native-federation-orchestrator': - specifier: ^4.0.0 - version: 4.2.1 + specifier: ^4.2.2 + version: 4.2.2 packages: @@ -2712,8 +2712,8 @@ packages: resolution: {integrity: sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw==, tarball: https://registry.npmjs.org/@sindresorhus/is/-/is-4.6.0.tgz} engines: {node: '>=10'} - '@softarc/native-federation-orchestrator@4.2.1': - resolution: {integrity: sha512-+EAngV2PrBSrs6VjPR+b0I7udxTxZGBszkXF6QdRpZoPIpNN9MXXNwLpl8MAenZcUAS1OvN5ocx3JGEiDj5ZYw==, tarball: https://registry.npmjs.org/@softarc/native-federation-orchestrator/-/native-federation-orchestrator-4.2.1.tgz} + '@softarc/native-federation-orchestrator@4.2.2': + resolution: {integrity: sha512-S2WCI/y2JiGykffK90+s9/Pkb4z5bBJey9c0bSNPXv0Ig9vcD3E9lUGJuP+oM/F24C0JoxxnT8o0bqjAlur16Q==, tarball: https://registry.npmjs.org/@softarc/native-federation-orchestrator/-/native-federation-orchestrator-4.2.2.tgz} engines: {node: '>=20.6.0'} '@softarc/native-federation@4.1.3': @@ -9583,7 +9583,7 @@ snapshots: '@sindresorhus/is@4.6.0': {} - '@softarc/native-federation-orchestrator@4.2.1': + '@softarc/native-federation-orchestrator@4.2.2': dependencies: semver: 7.8.1 @@ -11980,7 +11980,7 @@ snapshots: lodash.isstring: 4.0.1 lodash.once: 4.1.1 ms: 2.1.3 - semver: 7.8.0 + semver: 7.8.1 jsprim@2.0.2: dependencies: