@nf-beta/angular 0.0.1 → 0.0.3

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"}

package/src/tools/fstart-as-data-url.js

@@ -0,0 +1 @@
+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);
})();
';

package/src/utils/angular-esbuild-adapter.d.ts

@@ -0,0 +1,10 @@
+import { type BuildAdapter } from '@nf-beta/core/build';
+import * as esbuild from 'esbuild';
+import type { BuilderContext } from '@angular-devkit/architect';
+import type { ApplicationBuilderOptions } from '@angular/build';
+import { type RebuildEvents } from './rebuild-events.js';
+export type MemResultHandler = (outfiles: esbuild.OutputFile[], outdir?: string) => void;
+export declare function setMemResultHandler(handler: MemResultHandler): void;
+export declare function createAngularBuildAdapter(builderOptions: ApplicationBuilderOptions, context: BuilderContext, rebuildRequested?: RebuildEvents): BuildAdapter;
+export declare function loadEsmModule<T>(modulePath: string | URL): Promise<T>;
+//# sourceMappingURL=angular-esbuild-adapter.d.ts.map

package/src/utils/angular-esbuild-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"angular-esbuild-adapter.d.ts","sourceRoot":"","sources":["../../../src/utils/angular-esbuild-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,YAAY,EAMlB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,OAAO,MAAM,SAAS,CAAC;AAWnC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAShE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAQhE,OAAO,EAAE,KAAK,aAAa,EAAe,MAAM,qBAAqB,CAAC;AAMtE,MAAM,MAAM,gBAAgB,GAAG,CAAC,QAAQ,EAAE,OAAO,CAAC,UAAU,EAAE,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;AAKzF,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI,CAEnE;AAED,wBAAgB,yBAAyB,CACvC,cAAc,EAAE,yBAAyB,EACzC,OAAO,EAAE,cAAc,EACvB,gBAAgB,GAAE,aAAiC,GAClD,YAAY,CAwFd;AAgSD,wBAAgB,aAAa,CAAC,CAAC,EAAE,UAAU,EAAE,MAAM,GAAG,GAAG,GAAG,OAAO,CAAC,CAAC,CAAC,CAErE"}

package/src/utils/angular-esbuild-adapter.js

@@ -0,0 +1,289 @@
+import { AbortedError, logger, } from '@nf-beta/core/build';
+import * as esbuild from 'esbuild';
+import { transformSupportedBrowsersToTargets, getSupportedBrowsers, generateSearchDirectories, findTailwindConfiguration, loadPostcssConfiguration, } from '@angular/build/private';
+import { createCompilerPluginOptions } from './create-compiler-options.js';
+import { normalizeOptimization, normalizeSourceMaps, } from '@angular-devkit/build-angular/src/utils/index.js';
+import { createRequire } from 'node:module';
+import * as fs from 'fs';
+import * as path from 'path';
+import { createSharedMappingsPlugin } from './shared-mappings-plugin.js';
+import { transformAsync } from '@babel/core';
+import { RebuildHubs } from './rebuild-events.js';
+import JSON5 from 'json5';
+import { isDeepStrictEqual } from 'node:util';
+import { createAwaitableCompilerPlugin } from './create-awaitable-compiler-plugin.js';
+let _memResultHandler;
+// Todo: figure out if still necessary
+export function setMemResultHandler(handler) {
+    _memResultHandler = handler;
+}
+export function createAngularBuildAdapter(builderOptions, context, rebuildRequested = new RebuildHubs()) {
+    return async (options) => {
+        const { entryPoints, tsConfigPath, external, outdir, mappedPaths, kind, watch, dev, hash, platform, optimizedMappings, signal, } = options;
+        setNgServerMode();
+        const files = await runEsbuild(builderOptions, context, entryPoints, external, outdir, tsConfigPath, mappedPaths, watch, rebuildRequested, dev, kind, hash, undefined, undefined, undefined, platform, optimizedMappings, signal);
+        if (kind === 'shared-package') {
+            const scriptFiles = files.filter(f => f.endsWith('.js') || f.endsWith('.mjs'));
+            for (const file of scriptFiles) {
+                link(file, !!dev);
+            }
+        }
+        return files.map(fileName => ({ fileName }));
+    };
+    async function link(outfile, dev) {
+        const code = fs.readFileSync(outfile, 'utf-8');
+        try {
+            const linkerEsm = await loadEsmModule('@angular/compiler-cli/linker/babel');
+            const linker = linkerEsm.default;
+            const result = await transformAsync(code, {
+                filename: outfile,
+                compact: !dev,
+                configFile: false,
+                babelrc: false,
+                minified: !dev,
+                browserslistConfigFile: false,
+                plugins: [linker],
+            });
+            if (!result)
+                logger.warn(`File ${outfile} could not be linked.`);
+            if (!result?.code) {
+                logger.warn(`File ${outfile} seems to be empty.`);
+                return;
+            }
+            fs.writeFileSync(outfile, result.code, 'utf-8');
+        }
+        catch (e) {
+            logger.error('error linking');
+            if (fs.existsSync(`${outfile}.error`)) {
+                fs.unlinkSync(`${outfile}.error`);
+            }
+            fs.renameSync(outfile, `${outfile}.error`);
+            throw e;
+        }
+    }
+}
+async function runEsbuild(builderOptions, context, entryPoints, external, outdir, tsConfigPath, mappedPaths, watch, rebuildRequested = new RebuildHubs(), dev, kind, hash = false, plugins = null, absWorkingDir = undefined, logLevel = 'warning', platform, optimizedMappings, signal) {
+    if (signal?.aborted) {
+        throw new AbortedError('[angular-esbuild-adapter] Before building');
+    }
+    const workspaceRoot = context.workspaceRoot;
+    const projectMetadata = await context.getProjectMetadata(context.target.project);
+    const projectRoot = path.join(workspaceRoot, projectMetadata['root'] ?? '');
+    const browsers = getSupportedBrowsers(projectRoot, context.logger);
+    const target = transformSupportedBrowsersToTargets(browsers);
+    const optimizationOptions = normalizeOptimization(builderOptions.optimization);
+    const sourcemapOptions = normalizeSourceMaps(builderOptions.sourceMap);
+    const searchDirectories = await generateSearchDirectories([projectRoot, workspaceRoot]);
+    const postcssConfiguration = await loadPostcssConfiguration(searchDirectories);
+    const tailwindConfiguration = postcssConfiguration
+        ? undefined
+        : await getTailwindConfig(searchDirectories);
+    const outputNames = {
+        bundles: '[name]',
+        media: 'media/[name]',
+    };
+    let fileReplacements;
+    if (builderOptions.fileReplacements) {
+        for (const replacement of builderOptions.fileReplacements) {
+            fileReplacements ??= {};
+            fileReplacements[path.join(workspaceRoot, replacement.replace)] = path.join(workspaceRoot, replacement.with);
+        }
+    }
+    if (!optimizedMappings) {
+        tsConfigPath = createTsConfigForFederation(workspaceRoot, tsConfigPath, entryPoints);
+    }
+    const pluginOptions = createCompilerPluginOptions({
+        workspaceRoot,
+        optimizationOptions,
+        sourcemapOptions,
+        tsconfig: tsConfigPath,
+        outputNames,
+        fileReplacements,
+        externalDependencies: external,
+        preserveSymlinks: builderOptions.preserveSymlinks,
+        stylePreprocessorOptions: builderOptions.stylePreprocessorOptions,
+        advancedOptimizations: !dev,
+        inlineStyleLanguage: builderOptions.inlineStyleLanguage,
+        jit: false,
+        tailwindConfiguration,
+        postcssConfiguration,
+    }, target, undefined);
+    const commonjsPluginModule = await import('@chialab/esbuild-plugin-commonjs');
+    const commonjsPlugin = commonjsPluginModule.default;
+    pluginOptions.styleOptions.externalDependencies = [];
+    const [compilerPlugin, pluginDisposed] = createAwaitableCompilerPlugin(pluginOptions.pluginOptions, pluginOptions.styleOptions);
+    const config = {
+        entryPoints: entryPoints.map(ep => ({
+            in: ep.fileName,
+            out: path.parse(ep.outName).name,
+        })),
+        outdir,
+        entryNames: hash ? '[name]-[hash]' : '[name]',
+        write: false,
+        absWorkingDir,
+        external,
+        logLevel,
+        bundle: true,
+        sourcemap: sourcemapOptions.scripts,
+        minify: !dev,
+        supported: {
+            'async-await': false,
+            'object-rest-spread': false,
+        },
+        splitting: true, //kind === 'mapping-or-exposed',
+        platform: platform ?? 'browser',
+        format: 'esm',
+        target: target,
+        logLimit: kind === 'shared-package' ? 1 : 0,
+        plugins: plugins || [
+            compilerPlugin,
+            ...(mappedPaths && mappedPaths.length > 0 ? [createSharedMappingsPlugin(mappedPaths)] : []),
+            commonjsPlugin(),
+        ],
+        define: {
+            ...(!dev ? { ngDevMode: 'false' } : {}),
+            ngJitMode: 'false',
+        },
+        ...(builderOptions.loader ? { loader: builderOptions.loader } : {}),
+        resolveExtensions: ['.ts', '.tsx', '.mjs', '.js', '.cjs'],
+    };
+    const ctx = await esbuild.context(config);
+    try {
+        const abortHandler = async () => {
+            await ctx.cancel();
+            await ctx.dispose();
+            await pluginDisposed;
+        };
+        if (signal) {
+            signal.addEventListener('abort', abortHandler, { once: true });
+        }
+        const result = await ctx.rebuild();
+        const memOnly = dev && kind === 'mapping-or-exposed' && !!_memResultHandler;
+        const writtenFiles = writeResult(result, outdir, !!memOnly);
+        if (watch) {
+            // Also hardcoded disabled?
+            registerForRebuilds(kind ?? 'shared-package', rebuildRequested, ctx, outdir, !!memOnly);
+        }
+        else {
+            if (signal)
+                signal.removeEventListener('abort', abortHandler);
+            await ctx.dispose();
+            await pluginDisposed;
+        }
+        return writtenFiles;
+    }
+    catch (error) {
+        // ESBuild throws an error if the request is cancelled.
+        // if it is, it's changed to an 'AbortedError'
+        if (signal?.aborted && error instanceof Error && error.message.includes('canceled')) {
+            throw new AbortedError('[runEsbuild] ESBuild was canceled.');
+        }
+        throw error;
+    }
+}
+async function getTailwindConfig(searchDirectories) {
+    const tailwindConfigurationPath = findTailwindConfiguration(searchDirectories);
+    if (!tailwindConfigurationPath) {
+        return undefined;
+    }
+    return {
+        file: tailwindConfigurationPath,
+        package: createRequire(tailwindConfigurationPath).resolve('tailwindcss'),
+    };
+}
+function createTsConfigForFederation(workspaceRoot, tsConfigPath, entryPoints) {
+    const fullTsConfigPath = path.join(workspaceRoot, tsConfigPath);
+    const tsconfigDir = path.dirname(fullTsConfigPath);
+    const filtered = entryPoints
+        .filter(ep => !ep.fileName.includes('/node_modules/') && !ep.fileName.startsWith('.'))
+        .map(ep => path.relative(tsconfigDir, ep.fileName).replace(/\\\\/g, '/'));
+    const tsconfigAsString = fs.readFileSync(fullTsConfigPath, 'utf-8');
+    const tsconfig = JSON5.parse(tsconfigAsString);
+    if (!tsconfig.include) {
+        tsconfig.include = [];
+    }
+    for (const ep of filtered) {
+        if (!tsconfig.include.includes(ep)) {
+            tsconfig.include.push(ep);
+        }
+    }
+    const content = JSON5.stringify(tsconfig, null, 2);
+    const tsconfigFedPath = path.join(tsconfigDir, 'tsconfig.federation.json');
+    if (!doesFileExistAndJsonEqual(tsconfigFedPath, content)) {
+        fs.writeFileSync(tsconfigFedPath, JSON.stringify(tsconfig, null, 2));
+    }
+    tsConfigPath = tsconfigFedPath;
+    return tsConfigPath;
+}
+/**
+ * Checks if a file exists and if its content is equal to the provided content.
+ * If the file does not exist, it returns false.
+ * If the file or its content is invalid JSON, it returns false.
+ * @param {string} path - The path to the file
+ * @param {string} content - The content to compare with
+ * @returns {boolean} - Returns true if the file exists and its content is equal to the provided content
+ */
+function doesFileExistAndJsonEqual(path, content) {
+    if (!fs.existsSync(path)) {
+        return false;
+    }
+    try {
+        const currentContent = fs.readFileSync(path, 'utf-8');
+        const currentJson = JSON5.parse(currentContent);
+        const newJson = JSON5.parse(content);
+        return isDeepStrictEqual(currentJson, newJson);
+    }
+    catch {
+        return false;
+    }
+}
+function writeResult(result, outdir, memOnly) {
+    const writtenFiles = [];
+    if (memOnly) {
+        _memResultHandler(result.outputFiles ?? [], outdir);
+    }
+    for (const outFile of result.outputFiles ?? []) {
+        const fileName = path.basename(outFile.path);
+        const filePath = path.join(outdir, fileName);
+        if (!memOnly) {
+            fs.writeFileSync(filePath, outFile.text);
+        }
+        writtenFiles.push(filePath);
+    }
+    if (!memOnly) {
+        // for (const asset of result.outputFiles)
+    }
+    return writtenFiles;
+}
+function registerForRebuilds(kind, rebuildRequested, ctx, outdir, memOnly) {
+    if (kind !== 'shared-package') {
+        rebuildRequested.rebuild.register(async () => {
+            const result = await ctx.rebuild();
+            writeResult(result, outdir, memOnly);
+        });
+    }
+}
+export function loadEsmModule(modulePath) {
+    return new Function('modulePath', `return import(modulePath);`)(modulePath);
+}
+//
+//  Usually, ngServerMode is set during bundling. However, we need to infer this
+//  value at runtime as we are using the same shared bundle for @angular/core
+//  on the server and in the browser.
+//
+function setNgServerMode() {
+    const fileToPatch = 'node_modules/@angular/core/fesm2022/core.mjs';
+    const lineToAdd = `if (typeof globalThis.ngServerMode ==='undefined') globalThis.ngServerMode = (typeof window === 'undefined') ? true : false;`;
+    try {
+        if (fs.existsSync(fileToPatch)) {
+            let content = fs.readFileSync(fileToPatch, 'utf-8');
+            if (!content.includes(lineToAdd)) {
+                content = lineToAdd + '\n' + content;
+                fs.writeFileSync(fileToPatch, content);
+            }
+        }
+    }
+    catch {
+        console.error('Error patching file ', fileToPatch, '\nIs it write-protected?');
+    }
+}

package/src/utils/angular-locales.d.ts

@@ -0,0 +1,19 @@
+import { type SharedConfig } from '@nf-beta/core/build';
+export declare function shareAngularLocales(keys: string[], config?: SharedConfig): (string | {
+    [x: string]: SharedConfig & {
+        includeSecondaries?: boolean | {
+            skip: string | string[];
+            resolveGlob?: boolean;
+            keepAll?: boolean;
+        };
+    };
+})[] | {
+    [x: string]: SharedConfig & {
+        includeSecondaries?: boolean | {
+            skip: string | string[];
+            resolveGlob?: boolean;
+            keepAll?: boolean;
+        };
+    };
+};
+//# sourceMappingURL=angular-locales.d.ts.map

package/src/utils/angular-locales.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"angular-locales.d.ts","sourceRoot":"","sources":["../../../src/utils/angular-locales.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAE/D,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,EAAE,EACd,MAAM,GAAE,YAIP;;;;;;;;;;;;;;;;EAeF"}

package/src/utils/angular-locales.js

@@ -0,0 +1,18 @@
+import { share } from '@nf-beta/core/build';
+export function shareAngularLocales(keys, config = {
+    singleton: true,
+    strictVersion: true,
+    requiredVersion: 'auto',
+}) {
+    const locales = keys.reduce((acc, key) => {
+        acc[`@angular/common/locales/${key}`] = {
+            ...config,
+        };
+        acc[`@angular/common/locales/${key}`].packageInfo = {
+            ...(config.packageInfo ?? { esm: true, version: '0.0.0' }),
+            entryPoint: config.packageInfo?.entryPoint || `node_modules/@angular/common/locales/${key}.mjs`,
+        };
+        return acc;
+    }, {});
+    return share(locales);
+}

package/src/utils/create-awaitable-compiler-plugin.d.ts

@@ -0,0 +1,6 @@
+import type * as esbuild from 'esbuild';
+import { createCompilerPlugin } from '@angular/build/private';
+type CreateCompilerPluginParams = Parameters<typeof createCompilerPlugin>;
+export declare function createAwaitableCompilerPlugin(pluginOptions: CreateCompilerPluginParams[0], styleOptions: CreateCompilerPluginParams[1]): [esbuild.Plugin, Promise<void>];
+export {};
+//# sourceMappingURL=create-awaitable-compiler-plugin.d.ts.map