@angular-architects/native-federation 18.2.0 → 18.2.2

package/src/schematics/remove/schematic.ts

@@ -1,179 +0,0 @@
-import { Rule, Tree } from '@angular-devkit/schematics';
-
-import { MfSchematicSchema } from './schema';
-
-import * as path from 'path';
-
-type NormalizedOptions = {
-  polyfills: string;
-  projectName: string;
-  projectRoot: string;
-  projectSourceRoot: string;
-  manifestPath: string;
-  projectConfig: any;
-  main: string;
-};
-
-export default function remove(options: MfSchematicSchema): Rule {
-  return async function (tree /*, context*/) {
-    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: string, mainPath: string) {
-  if (tree.exists(bootstrapPath) && tree.exists(mainPath)) {
-    tree.delete(mainPath);
-    tree.rename(bootstrapPath, mainPath);
-  }
-}
-
-function updateWorkspaceConfig(
-  tree: Tree,
-  options: NormalizedOptions,
-  workspace: any,
-  workspaceFileName: string
-) {
-  const { projectConfig } = options;
-
-  if (!projectConfig?.architect?.build || !projectConfig?.architect?.serve) {
-    throw new Error(
-      `The project doen'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: MfSchematicSchema,
-  workspace: any
-): NormalizedOptions {
-  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!`);
-  }
-
-  const projectRoot: string = projectConfig.root?.replace(/\\/g, '/');
-  const projectSourceRoot: string = 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: any) {
-  if (typeof polyfills === 'string') {
-    updatePolyfillsFile(tree, polyfills);
-  } else {
-    updatePolyfillsArray(tree, polyfills);
-  }
-}
-
-function updatePolyfillsFile(tree, polyfills: any) {
-  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: any) {
-  const polyfillsConfig = polyfills as string[];
-
-  const index = polyfillsConfig.findIndex((p) => p === 'es-module-shims');
-  if (index === -1) {
-    return;
-  }
-
-  polyfillsConfig.splice(index, 1);
-}
-
-export function getWorkspaceFileName(tree: Tree): string {
-  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/schematic.ts

@@ -1,10 +0,0 @@
-import { Rule, Tree } from '@angular-devkit/schematics';
-
-import { patchAngularBuild, updatePackageJson } from '../init/schematic';
-
-export default function update18(): Rule {
-  return async function (tree: Tree) {
-    updatePackageJson(tree);
-    patchAngularBuild(tree);
-  };
-}

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

@@ -1,438 +0,0 @@
-import {
-  BuildAdapter,
-  logger,
-  MappedPath,
-} from '@softarc/native-federation/build';
-
-import * as esbuild from 'esbuild';
-
-import {
-  createCompilerPlugin,
-  transformSupportedBrowsersToTargets,
-  getSupportedBrowsers,
-} from '@angular/build/private';
-
-import { createCompilerPluginOptions } from './create-compiler-options';
-import { BuilderContext } from '@angular-devkit/architect';
-import { findTailwindConfigurationFile } from '@angular-devkit/build-angular/src/utils/tailwind';
-
-import {
-  normalizeOptimization,
-  normalizeSourceMaps,
-} from '@angular-devkit/build-angular/src/utils';
-import { createRequire } from 'node:module';
-
-import { ApplicationBuilderOptions } from '@angular/build';
-
-import * as fs from 'fs';
-import * as path from 'path';
-import { createSharedMappingsPlugin } from './shared-mappings-plugin';
-
-import { PluginItem, transformAsync } from '@babel/core';
-import {
-  BuildKind,
-  BuildResult,
-  EntryPoint,
-} from '@softarc/native-federation/build';
-
-import { RebuildEvents, RebuildHubs } from './rebuild-events';
-
-// const fesmFolderRegExp = /[/\\]fesm\d+[/\\]/;
-
-export type MemResultHandler = (
-  outfiles: esbuild.OutputFile[],
-  outdir?: string
-) => void;
-
-let _memResultHandler: MemResultHandler;
-
-export function setMemResultHandler(handler: MemResultHandler): void {
-  _memResultHandler = handler;
-}
-
-export function createAngularBuildAdapter(
-  builderOptions: ApplicationBuilderOptions,
-  context: BuilderContext,
-  rebuildRequested: RebuildEvents = new RebuildHubs()
-): BuildAdapter {
-  return async (options) => {
-    const {
-      entryPoints,
-      tsConfigPath,
-      external,
-      outdir,
-      mappedPaths,
-      kind,
-      watch,
-      dev,
-      hash,
-    } = options;
-
-    const files = await runEsbuild(
-      builderOptions,
-      context,
-      entryPoints,
-      external,
-      outdir,
-      tsConfigPath,
-      mappedPaths,
-      watch,
-      rebuildRequested,
-      dev,
-      kind,
-      hash
-    );
-
-    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 } as BuildResult));
-
-    // TODO: Do we still need rollup as esbuilt evolved?
-    // if (kind === 'shared-package') {
-    //   await runRollup(entryPoint, external, outfile);
-    // } else {
-
-    //   if (
-    //     dev &&
-    //     kind === 'shared-package' &&
-    //     entryPoint.match(fesmFolderRegExp)
-    //   ) {
-    //     fs.copyFileSync(entryPoint, outfile);
-    //   } else {
-    //     await runEsbuild(
-    //       builderOptions,
-    //       context,
-    //       entryPoint,
-    //       external,
-    //       outfile,
-    //       tsConfigPath,
-    //       mappedPaths,
-    //       watch,
-    //       rebuildRequested,
-    //       dev,
-    //       kind
-    //     );
-    //   }
-    //   if (kind === 'shared-package' && fs.existsSync(outfile)) {
-    //     await link(outfile, dev);
-    //   }
-    // }
-  };
-
-  async function link(outfile: string, dev: boolean) {
-    const code = fs.readFileSync(outfile, 'utf-8');
-
-    try {
-      const linkerEsm = await loadEsmModule<{ default: PluginItem }>(
-        '@angular/compiler-cli/linker/babel'
-      );
-
-      const linker = linkerEsm.default;
-
-      const result = await transformAsync(code, {
-        filename: outfile,
-        // inputSourceMap: (useInputSourcemap ? undefined : false) as undefined,
-        // sourceMaps: pluginOptions.sourcemap ? 'inline' : false,
-        compact: !dev,
-        configFile: false,
-        babelrc: false,
-        minified: !dev,
-        browserslistConfigFile: false,
-        plugins: [linker],
-      });
-
-      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: ApplicationBuilderOptions,
-  context: BuilderContext,
-  entryPoints: EntryPoint[],
-  external: string[],
-  outdir: string,
-  tsConfigPath: string,
-  mappedPaths: MappedPath[],
-  watch?: boolean,
-  rebuildRequested: RebuildEvents = new RebuildHubs(),
-  dev?: boolean,
-  kind?: BuildKind,
-  hash = false,
-  plugins: esbuild.Plugin[] | null = null,
-  absWorkingDir: string | undefined = undefined,
-  logLevel: esbuild.LogLevel = 'warning'
-) {
-  const projectRoot = path.dirname(tsConfigPath);
-  const browsers = getSupportedBrowsers(projectRoot, context.logger as any);
-  const target = transformSupportedBrowsersToTargets(browsers);
-
-  const workspaceRoot = context.workspaceRoot;
-
-  const optimizationOptions = normalizeOptimization(
-    builderOptions.optimization
-  );
-  const sourcemapOptions = normalizeSourceMaps(builderOptions.sourceMap);
-  const tailwindConfigurationPath = await findTailwindConfigurationFile(
-    workspaceRoot,
-    projectRoot
-  );
-
-  const fullProjectRoot = path.join(workspaceRoot, projectRoot);
-  const resolver = createRequire(fullProjectRoot + '/');
-
-  const tailwindConfiguration = tailwindConfigurationPath
-    ? {
-        file: tailwindConfigurationPath,
-        package: resolver.resolve('tailwindcss'),
-      }
-    : undefined;
-
-  const outputNames = {
-    bundles: '[name]',
-    media: 'media/[name]',
-  };
-
-  let fileReplacements: Record<string, string> | undefined;
-  if (builderOptions.fileReplacements) {
-    for (const replacement of builderOptions.fileReplacements) {
-      fileReplacements ??= {};
-      fileReplacements[path.join(workspaceRoot, replacement.replace)] =
-        path.join(workspaceRoot, replacement.with);
-    }
-  }
-
-  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,
-    } as any,
-    target,
-    undefined
-  );
-
-  pluginOptions.styleOptions.externalDependencies = [];
-
-  const config: esbuild.BuildOptions = {
-    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: dev,
-    minify: !dev,
-    supported: {
-      'async-await': false,
-      'object-rest-spread': false,
-    },
-    splitting: kind === 'mapping-or-exposed',
-    platform: 'browser',
-    format: 'esm',
-    target: ['esnext'],
-    logLimit: kind === 'shared-package' ? 1 : 0,
-    plugins: plugins || [
-      createCompilerPlugin(
-        pluginOptions.pluginOptions,
-        pluginOptions.styleOptions
-
-        // TODO: Once available, use helper functions
-        //  for creating these config objects:
-        //  @angular_devkit/build_angular/src/tools/esbuild/compiler-plugin-options.ts
-        // {
-        //   jit: false,
-        //   sourcemap: dev,
-        //   tsconfig: tsConfigPath,
-        //   advancedOptimizations: !dev,
-        //   thirdPartySourcemaps: false,
-        // },
-        // {
-        //   optimization: !dev,
-        //   sourcemap: dev ? 'inline' : false,
-        //   workspaceRoot: __dirname,
-        //   inlineStyleLanguage: builderOptions.inlineStyleLanguage,
-        //   // browsers: browsers,
-
-        //   target: target,
-        // }
-      ),
-      ...(mappedPaths && mappedPaths.length > 0
-        ? [createSharedMappingsPlugin(mappedPaths)]
-        : []),
-    ],
-    define: {
-      ...(!dev ? { ngDevMode: 'false' } : {}),
-      ngJitMode: 'false',
-    },
-  };
-
-  const ctx = await esbuild.context(config);
-  const result = await ctx.rebuild();
-
-  const memOnly = dev && kind === 'mapping-or-exposed' && !!_memResultHandler;
-
-  const writtenFiles = writeResult(result, outdir, memOnly);
-
-  if (watch) {
-    registerForRebuilds(
-      kind,
-      rebuildRequested,
-      ctx,
-      entryPoints,
-      outdir,
-      hash,
-      memOnly
-    );
-  } else {
-    ctx.dispose();
-  }
-
-  // cleanUpTsConfigForFederation(tsConfigPath);
-
-  return writtenFiles;
-}
-
-// function cleanUpTsConfigForFederation(tsConfigPath: string) {
-//   if (tsConfigPath.includes('.federation.')) {
-//     fs.unlinkSync(tsConfigPath);
-//   }
-// }
-
-function createTsConfigForFederation(
-  workspaceRoot: string,
-  tsConfigPath: string,
-  entryPoints: EntryPoint[]
-) {
-  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 tsconfigWithoutComments = tsconfigAsString.replace(
-    /\/\*.+?\*\/|\/\/.*(?=[\n\r])/g,
-    ''
-  );
-  const tsconfig = JSON.parse(tsconfigWithoutComments);
-
-  if (!tsconfig.include) {
-    tsconfig.include = [];
-  }
-
-  for (const ep of filtered) {
-    if (!tsconfig.include.includes(ep)) {
-      tsconfig.include.push(ep);
-    }
-  }
-
-  const content = JSON.stringify(tsconfig, null, 2);
-
-  const tsconfigFedPath = path.join(tsconfigDir, 'tsconfig.federation.json');
-
-  if (!doesFileExist(tsconfigFedPath, content)) {
-    fs.writeFileSync(tsconfigFedPath, JSON.stringify(tsconfig, null, 2));
-  }
-  tsConfigPath = tsconfigFedPath;
-  return tsConfigPath;
-}
-
-function doesFileExist(path: string, content: string): boolean {
-  if (!fs.existsSync(path)) {
-    return false;
-  }
-  const currentContent = fs.readFileSync(path, 'utf-8');
-  return currentContent === content;
-}
-
-function writeResult(
-  result: esbuild.BuildResult<esbuild.BuildOptions>,
-  outdir: string,
-  memOnly: boolean
-) {
-  const writtenFiles: string[] = [];
-
-  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: BuildKind,
-  rebuildRequested: RebuildEvents,
-  ctx: esbuild.BuildContext<esbuild.BuildOptions>,
-  entryPoints: EntryPoint[],
-  outdir: string,
-  hash: boolean,
-  memOnly: boolean
-) {
-  if (kind !== 'shared-package') {
-    rebuildRequested.rebuild.register(async () => {
-      const result = await ctx.rebuild();
-      writeResult(result, outdir, memOnly);
-    });
-  }
-}
-
-export function loadEsmModule<T>(modulePath: string | URL): Promise<T> {
-  return new Function('modulePath', `return import(modulePath);`)(
-    modulePath
-  ) as Promise<T>;
-}

package/src/utils/create-compiler-options.ts

@@ -1,68 +0,0 @@
-// Taken from https://github.com/angular/angular-cli/blob/main/packages/angular/build/src/tools/esbuild/compiler-plugin-options.ts
-// Currently, this type cannot be accessed from the outside
-
-export function createCompilerPluginOptions(
-  options: any,
-  target: string[],
-  sourceFileCache?: any
-): {
-  pluginOptions: any[0];
-  styleOptions: any[1];
-} {
-  const {
-    workspaceRoot,
-    optimizationOptions,
-    sourcemapOptions,
-    tsconfig,
-    outputNames,
-    fileReplacements,
-    externalDependencies,
-    preserveSymlinks,
-    stylePreprocessorOptions,
-    advancedOptimizations,
-    inlineStyleLanguage,
-    jit,
-    cacheOptions,
-    tailwindConfiguration,
-    postcssConfiguration,
-    publicPath,
-  } = options;
-
-  return {
-    // JS/TS options
-    pluginOptions: {
-      sourcemap:
-        !!sourcemapOptions.scripts &&
-        (sourcemapOptions.hidden ? 'external' : true),
-      thirdPartySourcemaps: sourcemapOptions.vendor,
-      tsconfig,
-      jit,
-      advancedOptimizations,
-      fileReplacements,
-      sourceFileCache,
-      loadResultCache: sourceFileCache?.loadResultCache,
-      incremental: !!options.watch,
-    },
-    // Component stylesheet options
-    styleOptions: {
-      workspaceRoot,
-      inlineFonts: !!optimizationOptions.fonts.inline,
-      optimization: !!optimizationOptions.styles.minify,
-      sourcemap:
-        // Hidden component stylesheet sourcemaps are inaccessible which is effectively
-        // the same as being disabled. Disabling has the advantage of avoiding the overhead
-        // of sourcemap processing.
-        sourcemapOptions.styles && !sourcemapOptions.hidden ? 'linked' : false,
-      outputNames,
-      includePaths: stylePreprocessorOptions?.includePaths,
-      externalDependencies,
-      target,
-      inlineStyleLanguage,
-      preserveSymlinks,
-      tailwindConfiguration,
-      postcssConfiguration,
-      cacheOptions,
-      publicPath,
-    },
-  };
-}