@nf-beta/angular 0.0.1 → 0.0.2

package/src/schematics/init/schematic.js

@@ -0,0 +1,422 @@
+import { apply, chain, mergeWith, move, noop, template, url, } from '@angular-devkit/schematics';
+import { strings } from '@angular-devkit/core';
+import { NodePackageInstallTask } from '@angular-devkit/schematics/tasks';
+import { patchAngularBuildPackageJson, privateEntrySrc } from '../../utils/patch-angular-build.js';
+import { addPackageJsonDependency, getPackageJsonDependency, NodeDependencyType, } from '@schematics/angular/utility/dependencies';
+import * as path from 'path';
+const SSR_VERSION = '^3.3.4';
+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));
+}
+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.js');
+        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
+            ? await generateFederationConfig(remoteMap, projectRoot, projectSourceRoot, appComponent, options)
+            : noop;
+        const ssr = isSsrProject(normalized);
+        const server = ssr ? getSsrFilePath(normalized) : '';
+        if (ssr) {
+            console.log('SSR detected ...');
+            console.log('Activating CORS ...');
+            addPackageJsonDependency(tree, {
+                name: 'cors',
+                type: NodeDependencyType.Default,
+                version: '^2.8.5',
+                overwrite: false,
+            });
+        }
+        updateWorkspaceConfig(tree, normalized, workspace, workspaceFileName, ssr);
+        // updatePackageJson(tree);
+        // patchAngularBuild(tree);
+        addPackageJsonDependency(tree, {
+            name: '@angular/animations',
+            type: NodeDependencyType.Default,
+            version: getPackageJsonDependency(tree, '@angular/core')?.version || 'latest',
+            overwrite: false,
+        });
+        addPackageJsonDependency(tree, {
+            name: '@angular-devkit/build-angular',
+            type: NodeDependencyType.Dev,
+            version: getPackageJsonDependency(tree, '@angular/build')?.version || 'latest',
+            overwrite: false,
+        });
+        addPackageJsonDependency(tree, {
+            name: 'es-module-shims',
+            type: NodeDependencyType.Default,
+            version: '^1.5.12',
+            overwrite: false,
+        });
+        addPackageJsonDependency(tree, {
+            name: '@nf-beta/core-node',
+            type: NodeDependencyType.Default,
+            version: SSR_VERSION,
+            overwrite: true,
+        });
+        context.addTask(new NodePackageInstallTask());
+        return chain([
+            generateRule,
+            makeMainAsync(main, options, remoteMap, manifestRelPath),
+            ssr ? makeServerAsync(server, options, remoteMap) : noop(),
+        ]);
+    };
+}
+function isSsrProject(normalized) {
+    return !!normalized.projectConfig?.architect?.build.options?.ssr;
+}
+function getSsrFilePath(normalized) {
+    return normalized.projectConfig.architect.build.options.ssr.entry;
+}
+export function patchAngularBuild(tree) {
+    const packagePath = 'node_modules/@angular/build/package.json';
+    const privatePath = 'node_modules/@angular/build/private.js';
+    if (!tree.exists(packagePath)) {
+        return;
+    }
+    const packageJson = JSON.parse(tree.read(packagePath)?.toString('utf8') ?? '{}');
+    patchAngularBuildPackageJson(packageJson);
+    tree.overwrite(packagePath, JSON.stringify(packageJson, null, 2));
+    if (!tree.exists(privatePath)) {
+        tree.create(privatePath, privateEntrySrc);
+    }
+    else {
+        tree.overwrite(privatePath, privateEntrySrc);
+    }
+}
+function updateWorkspaceConfig(tree, options, workspace, workspaceFileName, ssr) {
+    const { projectConfig, projectName, port } = options;
+    if (!projectConfig?.architect?.build || !projectConfig?.architect?.serve) {
+        throw new Error(`The project doesn't have a build or serve target in angular.json!`);
+    }
+    const originalBuild = projectConfig.architect.build;
+    if (originalBuild.builder !== '@angular-devkit/build-angular:application' ||
+        originalBuild.builder !== '@angular/build:application') {
+        console.log('Switching project to the application builder using esbuild ...');
+        originalBuild.builder = '@angular/build:application';
+        delete originalBuild.configurations?.development?.buildOptimizer;
+        delete originalBuild.configurations?.development?.vendorChunk;
+    }
+    if (originalBuild.options.main) {
+        const main = originalBuild.options.main;
+        delete originalBuild.options.main;
+        originalBuild.options.browser = main;
+    }
+    delete originalBuild.options.commonChunk;
+    projectConfig.architect.esbuild = originalBuild;
+    projectConfig.architect.build = {
+        builder: '@angular-architects/native-federation:build',
+        options: {},
+        configurations: {
+            production: {
+                target: `${projectName}:esbuild:production`,
+            },
+            development: {
+                target: `${projectName}:esbuild:development`,
+                dev: true,
+            },
+        },
+        defaultConfiguration: 'production',
+    };
+    if (ssr) {
+        projectConfig.architect.build.options.ssr = true;
+        // projectConfig.architect.esbuild.options.prerender = false;
+    }
+    const serve = projectConfig.architect.serve;
+    serve.options ??= {};
+    serve.options.port = port;
+    delete serve.options.commonChunk;
+    const serveProd = projectConfig.architect.serve.configurations?.production;
+    if (serveProd) {
+        serveProd.buildTarget = `${projectName}:esbuild:production`;
+        delete serveProd.browserTarget;
+    }
+    const serveDev = projectConfig.architect.serve.configurations?.development;
+    if (serveDev) {
+        serveDev.buildTarget = `${projectName}:esbuild:development`;
+        delete serveDev.browserTarget;
+    }
+    projectConfig.architect['serve-original'] = projectConfig.architect.serve;
+    projectConfig.architect.serve = {
+        builder: '@angular-architects/native-federation:build',
+        options: {
+            target: `${projectName}:serve-original:development`,
+            rebuildDelay: 500,
+            dev: true,
+            cacheExternalArtifacts: false,
+            port: 0,
+        },
+    };
+    const serveSsr = projectConfig.architect['serve-ssr'];
+    if (serveSsr && !serveSsr.options) {
+        serveSsr.options = {};
+    }
+    if (serveSsr) {
+        serveSsr.options.port = port;
+    }
+    // projectConfig.architect.serve.builder = serveBuilder;
+    // TODO: Register further builders when ready
+    tree.overwrite(workspaceFileName, JSON.stringify(workspace, null, '\t'));
+}
+function normalizeOptions(options, workspace, tree) {
+    if (!options.project) {
+        options.project = workspace.defaultProject;
+    }
+    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;
+    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),
+    };
+}
+function updatePolyfills(tree, polyfills) {
+    if (typeof polyfills === 'string') {
+        updatePolyfillsFile(tree, polyfills);
+    }
+    else {
+        updatePolyfillsArray(tree, polyfills);
+    }
+}
+function updatePolyfillsFile(tree, polyfills) {
+    let polyfillsContent = tree.readText(polyfills);
+    if (!polyfillsContent.includes('es-module-shims')) {
+        polyfillsContent += `\nimport 'es-module-shims';\n`;
+        tree.overwrite(polyfills, polyfillsContent);
+    }
+}
+function updatePolyfillsArray(_tree, polyfills) {
+    const polyfillsConfig = polyfills;
+    if (!polyfillsConfig.includes('es-module-shims')) {
+        polyfillsConfig.push('es-module-shims');
+    }
+}
+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`;
+        }
+    }
+    if (Object.keys(result).length === 0) {
+        result['mfe1'] = `http://localhost:3000/remoteEntry.json`;
+    }
+    return result;
+}
+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);
+        let newMainContent = '';
+        if (options.type === 'dynamic-host') {
+            newMainContent = `import { initFederation } from '@angular-architects/native-federation';
+
+initFederation('${manifestRelPath}')
+  .catch(err => console.error(err))
+  .then(_ => import('./bootstrap'))
+  .catch(err => console.error(err));
+`;
+        }
+        else if (options.type === 'host') {
+            const manifest = JSON.stringify(remoteMap, null, 2).replace(/"/g, "'");
+            newMainContent = `import { initFederation } from '@angular-architects/native-federation';
+
+initFederation(${manifest})
+  .catch(err => console.error(err))
+  .then(_ => import('./bootstrap'))
+  .catch(err => console.error(err));
+`;
+        }
+        else {
+            newMainContent = `import { initFederation } from '@angular-architects/native-federation';
+
+initFederation()
+  .catch(err => console.error(err))
+  .then(_ => import('./bootstrap'))
+  .catch(err => console.error(err));
+`;
+        }
+        tree.overwrite(main, newMainContent);
+    };
+}
+function makeServerAsync(server, options, remoteMap) {
+    return async function (tree) {
+        const mainPath = path.dirname(server);
+        const bootstrapName = path.join(mainPath, 'bootstrap-server.ts');
+        if (tree.exists(bootstrapName)) {
+            console.info(`${bootstrapName} already exists.`);
+            return;
+        }
+        const cors = `import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+const cors = require("cors");
+`;
+        const mainContent = tree.read(server)?.toString('utf8');
+        const updatedContent = (cors + mainContent)
+            .replace(`const port = process.env['PORT'] || 4000`, `const port = process.env['PORT'] || ${options.port || 4000}`)
+            .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 '@nf-beta/core-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 '@nf-beta/core-node';
+
+console.log('Starting SSR for Shell');
+
+(async () => {
+
+  await initNodeFederation({
+    remotesOrManifestUrl: ${manifest},
+    relBundlePath: '../browser/',
+  });
+
+  await import('./bootstrap-server');
+
+})();
+`;
+        }
+        else {
+            newMainContent = `import { initNodeFederation } from '@nf-beta/core-node';
+
+(async () => {
+
+  await initNodeFederation({
+    relBundlePath: '../browser/'
+  });
+
+  await import('./bootstrap-server');
+
+})();
+`;
+        }
+        tree.overwrite(server, newMainContent);
+    };
+}
+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?");
+}
+async function generateFederationConfig(remoteMap, projectRoot, projectSourceRoot, appComponentPath, options) {
+    const tmpl = url('./files');
+    const applied = apply(tmpl, [
+        template({
+            projectRoot,
+            projectSourceRoot,
+            appComponentPath,
+            remoteMap,
+            ...options,
+            tmpl: '',
+        }),
+        move(projectRoot),
+    ]);
+    return mergeWith(applied);
+}

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

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

package/src/schematics/remove/schema.json

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"schematic.d.ts","sourceRoot":"","sources":["../../../../src/schematics/remove/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,CAgB/D;AAmHD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAUvD"}

package/src/schematics/remove/schematic.js

@@ -0,0 +1,109 @@
+import * as path from 'path';
+export default function remove(options) {
+    return async function (tree) {
+        const workspaceFileName = getWorkspaceFileName(tree);
+        const workspace = JSON.parse(tree.read(workspaceFileName)?.toString('utf8') ?? '{}');
+        const normalized = normalizeOptions(options, workspace);
+        const { polyfills, projectRoot } = normalized;
+        const bootstrapPath = path.join(projectRoot, 'src/bootstrap.ts');
+        const mainPath = path.join(projectRoot, 'src/main.ts');
+        makeMainSync(tree, bootstrapPath, mainPath);
+        updatePolyfills(tree, polyfills);
+        updateWorkspaceConfig(tree, normalized, workspace, workspaceFileName);
+    };
+}
+function makeMainSync(tree, bootstrapPath, mainPath) {
+    if (tree.exists(bootstrapPath) && tree.exists(mainPath)) {
+        tree.delete(mainPath);
+        tree.rename(bootstrapPath, mainPath);
+    }
+}
+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.build = projectConfig.architect.esbuild;
+        delete projectConfig.architect.esbuild;
+    }
+    if (projectConfig.architect['serve-original']) {
+        projectConfig.architect.serve = projectConfig.architect['serve-original'];
+        delete projectConfig.architect['serve-original'];
+    }
+    if (projectConfig.architect.serve) {
+        const conf = projectConfig.architect.serve.configurations;
+        conf.production.buildTarget = conf.production.buildTarget.replace(':esbuild:', ':build:');
+        conf.development.buildTarget = conf.development.buildTarget.replace(':esbuild:', ':build:');
+    }
+    tree.overwrite(workspaceFileName, JSON.stringify(workspace, null, '\t'));
+}
+function normalizeOptions(options, workspace) {
+    if (!options.project) {
+        options.project = workspace.defaultProject;
+    }
+    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,
+    };
+}
+function updatePolyfills(tree, polyfills) {
+    if (typeof polyfills === 'string') {
+        updatePolyfillsFile(tree, polyfills);
+    }
+    else {
+        updatePolyfillsArray(tree, polyfills);
+    }
+}
+function updatePolyfillsFile(tree, polyfills) {
+    let polyfillsContent = tree.readText(polyfills);
+    if (polyfillsContent.includes('es-module-shims')) {
+        polyfillsContent = polyfillsContent.replace(`import 'es-module-shims';`, '');
+        tree.overwrite(polyfills, polyfillsContent);
+    }
+}
+function updatePolyfillsArray(_tree, polyfills) {
+    const polyfillsConfig = polyfills;
+    const index = polyfillsConfig.findIndex(p => p === 'es-module-shims');
+    if (index === -1) {
+        return;
+    }
+    polyfillsConfig.splice(index, 1);
+}
+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/update18/schema.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "mf",
+  "title": "",
+  "type": "object",
+  "properties": {}
+}

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

@@ -0,0 +1,3 @@
+import type { Rule } from '@angular-devkit/schematics';
+export default function update18(): Rule;
+//# sourceMappingURL=schematic.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schematic.d.ts","sourceRoot":"","sources":["../../../../src/schematics/update18/schematic.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAQ,MAAM,4BAA4B,CAAC;AAI7D,MAAM,CAAC,OAAO,UAAU,QAAQ,IAAI,IAAI,CAKvC"}

package/src/schematics/update18/schematic.js

@@ -0,0 +1,7 @@
+import { patchAngularBuild, updatePackageJson } from '../init/schematic.js';
+export default function update18() {
+    return async function (tree) {
+        updatePackageJson(tree);
+        patchAngularBuild(tree);
+    };
+}

package/src/tools/fstart-as-data-url.d.ts

@@ -0,0 +1,2 @@
+export declare 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);
})();
";
+//# sourceMappingURL=fstart-as-data-url.d.ts.map

package/src/tools/fstart-as-data-url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fstart-as-data-url.d.ts","sourceRoot":"","sources":["../../../src/tools/fstart-as-data-url.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,MAAM,i8/BAC66/B,CAAC"}