@nx/angular 17.2.0-beta.9 → 17.2.0-canary.20231207-b8d24e6

package/src/executors/browser-esbuild/schema.json

@@ -2,6 +2,7 @@
   "$schema": "http://json-schema.org/draft-07/schema",
   "title": "Schema for Nx ESBuild Executor",
   "description": "Nx ESBuild Executor supporting Incremental Builds.",
+  "examplesFile": "../../../docs/browser-esbuild-examples.md",
   "outputCapture": "direct-nodejs",
   "type": "object",
   "properties": {
@@ -441,6 +442,35 @@
       "type": "boolean",
       "description": "Read buildable libraries from source instead of building them separately.",
       "default": true
+    },
+    "plugins": {
+      "description": "A list of ESBuild plugins. _Note: this is only supported in Angular versions >= 17.0.0_.",
+      "type": "array",
+      "items": {
+        "oneOf": [
+          {
+            "type": "object",
+            "properties": {
+              "path": {
+                "type": "string",
+                "description": "The path to the plugin. Relative to the workspace root."
+              },
+              "options": {
+                "type": "object",
+                "description": "The options to provide to the plugin.",
+                "properties": {},
+                "additionalProperties": true
+              }
+            },
+            "additionalProperties": false,
+            "required": ["path"]
+          },
+          {
+            "type": "string",
+            "description": "The path to the plugin. Relative to the workspace root."
+          }
+        ]
+      }
     }
   },
   "additionalProperties": false,

package/src/executors/module-federation-dev-server/lib/build-static-remotes.d.ts

@@ -0,0 +1,7 @@
+import { type Schema } from '../schema';
+import { type ExecutorContext } from '@nx/devkit';
+export declare function buildStaticRemotes(remotes: {
+    remotePorts: any[];
+    staticRemotes: string[];
+    devRemotes: string[];
+}, nxBin: any, context: ExecutorContext, options: Schema): Promise<void>;

package/src/executors/module-federation-dev-server/lib/build-static-remotes.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildStaticRemotes = void 0;
+const devkit_1 = require("@nx/devkit");
+const child_process_1 = require("child_process");
+async function buildStaticRemotes(remotes, nxBin, context, options) {
+    if (!remotes.staticRemotes ||
+        (Array.isArray(remotes.staticRemotes) && !remotes.staticRemotes.length)) {
+        return;
+    }
+    const mappedLocationOfRemotes = {};
+    for (const app of remotes.staticRemotes) {
+        mappedLocationOfRemotes[app] = `http${options.ssl ? 's' : ''}://${options.host}:${options.staticRemotesPort}/${app}`;
+    }
+    process.env.NX_MF_DEV_SERVER_STATIC_REMOTES = JSON.stringify(mappedLocationOfRemotes);
+    await new Promise((res) => {
+        devkit_1.logger.info(`NX Building ${remotes.staticRemotes.length} static remotes...`);
+        const staticProcess = (0, child_process_1.fork)(nxBin, [
+            'run-many',
+            `--target=build`,
+            `--projects=${remotes.staticRemotes.join(',')}`,
+            ...(context.configurationName
+                ? [`--configuration=${context.configurationName}`]
+                : []),
+            ...(options.parallel ? [`--parallel=${options.parallel}`] : []),
+        ], {
+            cwd: context.root,
+            stdio: ['ignore', 'pipe', 'pipe', 'ipc'],
+        });
+        staticProcess.stdout.on('data', (data) => {
+            const ANSII_CODE_REGEX = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
+            const stdoutString = data.toString().replace(ANSII_CODE_REGEX, '');
+            if (stdoutString.includes('Successfully ran target build')) {
+                staticProcess.stdout.removeAllListeners('data');
+                devkit_1.logger.info(`NX Built ${remotes.staticRemotes.length} static remotes`);
+                res();
+            }
+        });
+        staticProcess.stderr.on('data', (data) => devkit_1.logger.info(data.toString()));
+        staticProcess.on('exit', (code) => {
+            if (code !== 0) {
+                throw new Error(`Remotes failed to build. See above for errors.`);
+            }
+        });
+        process.on('SIGTERM', () => staticProcess.kill('SIGTERM'));
+        process.on('exit', () => staticProcess.kill('SIGTERM'));
+    });
+}
+exports.buildStaticRemotes = buildStaticRemotes;

package/src/executors/module-federation-dev-server/lib/index.d.ts

@@ -0,0 +1,4 @@
+export * from './build-static-remotes';
+export * from './normalize-options';
+export * from './start-dev-remotes';
+export * from './start-static-remotes-file-server';

package/src/executors/module-federation-dev-server/lib/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./build-static-remotes"), exports);
+tslib_1.__exportStar(require("./normalize-options"), exports);
+tslib_1.__exportStar(require("./start-dev-remotes"), exports);
+tslib_1.__exportStar(require("./start-static-remotes-file-server"), exports);

package/src/executors/module-federation-dev-server/lib/normalize-options.d.ts

@@ -0,0 +1,2 @@
+import type { NormalizedSchema, Schema } from '../schema';
+export declare function normalizeOptions(schema: Schema): NormalizedSchema;

package/src/executors/module-federation-dev-server/lib/normalize-options.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeOptions = void 0;
+function normalizeOptions(schema) {
+    let buildTarget = schema.buildTarget;
+    if (schema.browserTarget) {
+        buildTarget ??= schema.browserTarget;
+        delete schema.browserTarget;
+    }
+    return {
+        ...schema,
+        buildTarget,
+        host: schema.host ?? 'localhost',
+        port: schema.port ?? 4200,
+        liveReload: schema.liveReload ?? true,
+        open: schema.open ?? false,
+        ssl: schema.ssl ?? false,
+    };
+}
+exports.normalizeOptions = normalizeOptions;

package/src/executors/module-federation-dev-server/lib/start-dev-remotes.d.ts

@@ -0,0 +1,9 @@
+import { type Schema } from '../schema';
+import { type ExecutorContext, type ProjectConfiguration } from '@nx/devkit';
+export declare function startDevRemotes(remotes: {
+    remotePorts: any[];
+    staticRemotes: string[];
+    devRemotes: string[];
+}, workspaceProjects: Record<string, ProjectConfiguration>, options: Schema, context: ExecutorContext): Promise<AsyncIterable<{
+    success: boolean;
+}>[]>;

package/src/executors/module-federation-dev-server/lib/start-dev-remotes.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startDevRemotes = void 0;
+const devkit_1 = require("@nx/devkit");
+async function startDevRemotes(remotes, workspaceProjects, options, context) {
+    const devRemotesIters = [];
+    for (const app of remotes.devRemotes) {
+        if (!workspaceProjects[app].targets?.['serve']) {
+            throw new Error(`Could not find "serve" target in "${app}" project.`);
+        }
+        else if (!workspaceProjects[app].targets?.['serve'].executor) {
+            throw new Error(`Could not find executor for "serve" target in "${app}" project.`);
+        }
+        const [collection, executor] = workspaceProjects[app].targets['serve'].executor.split(':');
+        const isUsingModuleFederationDevServerExecutor = executor.includes('module-federation-dev-server');
+        devRemotesIters.push(await (0, devkit_1.runExecutor)({
+            project: app,
+            target: 'serve',
+            configuration: context.configurationName,
+        }, {
+            verbose: options.verbose ?? false,
+            ...(isUsingModuleFederationDevServerExecutor
+                ? { isInitialHost: false }
+                : {}),
+        }, context));
+    }
+    return devRemotesIters;
+}
+exports.startDevRemotes = startDevRemotes;

package/src/executors/module-federation-dev-server/lib/start-static-remotes-file-server.d.ts

@@ -0,0 +1,12 @@
+import { type ExecutorContext } from '@nx/devkit';
+import { type Schema } from '../schema';
+export declare function startStaticRemotesFileServer(remotes: {
+    remotePorts: any[];
+    staticRemotes: string[];
+    devRemotes: string[];
+}, context: ExecutorContext, options: Schema): AsyncGenerator<{
+    success: boolean;
+    baseUrl: string;
+}, {
+    success: boolean;
+}, unknown>;

package/src/executors/module-federation-dev-server/lib/start-static-remotes-file-server.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startStaticRemotesFileServer = void 0;
+const devkit_1 = require("@nx/devkit");
+const file_server_impl_1 = require("@nx/web/src/executors/file-server/file-server.impl");
+const path_1 = require("path");
+const fs_1 = require("fs");
+function startStaticRemotesFileServer(remotes, context, options) {
+    let shouldMoveToCommonLocation = false;
+    let commonOutputDirectory;
+    for (const app of remotes.staticRemotes) {
+        const outputPath = context.projectGraph.nodes[app].data.targets['build'].options.outputPath;
+        const directoryOfOutputPath = (0, path_1.dirname)(outputPath);
+        if (!commonOutputDirectory) {
+            commonOutputDirectory = directoryOfOutputPath;
+        }
+        else if (commonOutputDirectory !== directoryOfOutputPath ||
+            !outputPath.endsWith(app)) {
+            shouldMoveToCommonLocation = true;
+        }
+    }
+    if (shouldMoveToCommonLocation) {
+        commonOutputDirectory = (0, path_1.join)(devkit_1.workspaceRoot, 'tmp/static-remotes');
+        for (const app of remotes.staticRemotes) {
+            const outputPath = context.projectGraph.nodes[app].data.targets['build'].options
+                .outputPath;
+            (0, fs_1.cpSync)(outputPath, (0, path_1.join)(commonOutputDirectory, app), {
+                force: true,
+                recursive: true,
+            });
+        }
+    }
+    const staticRemotesIter = (0, file_server_impl_1.default)({
+        cors: true,
+        watch: false,
+        staticFilePath: commonOutputDirectory,
+        parallel: false,
+        spa: false,
+        withDeps: false,
+        host: options.host,
+        port: options.staticRemotesPort,
+        ssl: options.ssl,
+        sslCert: options.sslCert,
+        sslKey: options.sslKey,
+    }, context);
+    return staticRemotesIter;
+}
+exports.startStaticRemotesFileServer = startStaticRemotesFileServer;

package/src/executors/module-federation-dev-server/module-federation-dev-server.impl.d.ts

@@ -0,0 +1,3 @@
+import { type ExecutorContext } from '@nx/devkit';
+import { type Schema } from './schema';
+export default function moduleFederationDevServerExecutor(schema: Schema, context: ExecutorContext): AsyncGenerator<any, any, undefined>;

package/src/executors/module-federation-dev-server/module-federation-dev-server.impl.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const lib_1 = require("./lib");
+const rxjs_for_await_1 = require("@nx/devkit/src/utils/rxjs-for-await");
+const async_iterable_1 = require("@nx/devkit/src/utils/async-iterable");
+const module_federation_1 = require("@nx/webpack/src/utils/module-federation");
+const wait_for_port_open_1 = require("@nx/web/src/utils/wait-for-port-open");
+const file_server_impl_1 = require("@nx/web/src/executors/file-server/file-server.impl");
+const ngcli_adapter_1 = require("nx/src/adapter/ngcli-adapter");
+const dev_server_impl_1 = require("../../builders/dev-server/dev-server.impl");
+const module_federation_2 = require("../../builders/utilities/module-federation");
+const path_1 = require("path");
+const fs_1 = require("fs");
+async function* moduleFederationDevServerExecutor(schema, context) {
+    // Force Node to resolve to look for the nx binary that is inside node_modules
+    const nxBin = require.resolve('nx/bin/nx');
+    const options = (0, lib_1.normalizeOptions)(schema);
+    options.staticRemotesPort ??= options.port + 1;
+    const { projects: workspaceProjects } = (0, devkit_1.readProjectsConfigurationFromProjectGraph)(context.projectGraph);
+    const project = workspaceProjects[context.projectName];
+    const currIter = options.static
+        ? (0, file_server_impl_1.default)({
+            port: options.port,
+            host: options.host,
+            ssl: options.ssl,
+            buildTarget: options.buildTarget,
+            parallel: false,
+            spa: false,
+            withDeps: false,
+            cors: true,
+        }, context)
+        : (0, rxjs_for_await_1.eachValueFrom)((0, dev_server_impl_1.executeDevServerBuilder)(options, await (0, ngcli_adapter_1.createBuilderContext)({
+            builderName: '@nx/angular:webpack-browser',
+            description: 'Build a browser application',
+            optionSchema: await Promise.resolve().then(() => require('../../builders/webpack-browser/schema.json')),
+        }, context)));
+    if (options.isInitialHost === false) {
+        return yield* currIter;
+    }
+    let pathToManifestFile = (0, path_1.join)(context.root, project.sourceRoot, 'assets/module-federation.manifest.json');
+    if (options.pathToManifestFile) {
+        const userPathToManifestFile = (0, path_1.join)(context.root, options.pathToManifestFile);
+        if (!(0, fs_1.existsSync)(userPathToManifestFile)) {
+            throw new Error(`The provided Module Federation manifest file path does not exist. Please check the file exists at "${userPathToManifestFile}".`);
+        }
+        else if ((0, path_1.extname)(options.pathToManifestFile) !== '.json') {
+            throw new Error(`The Module Federation manifest file must be a JSON. Please ensure the file at ${userPathToManifestFile} is a JSON.`);
+        }
+        pathToManifestFile = userPathToManifestFile;
+    }
+    (0, module_federation_2.validateDevRemotes)(options, workspaceProjects);
+    const moduleFederationConfig = (0, module_federation_1.getModuleFederationConfig)(project.targets.build.options.tsConfig, context.root, project.root, 'angular');
+    const remotes = (0, module_federation_1.getRemotes)(options.devRemotes, options.skipRemotes, moduleFederationConfig, {
+        projectName: project.name,
+        projectGraph: context.projectGraph,
+        root: context.root,
+    }, pathToManifestFile);
+    if (remotes.devRemotes.length > 0 && !schema.staticRemotesPort) {
+        options.staticRemotesPort = options.devRemotes.reduce((portToUse, r) => {
+            const remotePort = context.projectGraph.nodes[r].data.targets['serve'].options.port;
+            if (remotePort >= portToUse) {
+                return remotePort + 1;
+            }
+            else {
+                return portToUse;
+            }
+        }, options.staticRemotesPort);
+    }
+    await (0, lib_1.buildStaticRemotes)(remotes, nxBin, context, options);
+    const devRemoteIters = await (0, lib_1.startDevRemotes)(remotes, workspaceProjects, options, context);
+    const staticRemotesIter = remotes.staticRemotes.length > 0
+        ? (0, lib_1.startStaticRemotesFileServer)(remotes, context, options)
+        : undefined;
+    const removeBaseUrlEmission = (iter) => (0, async_iterable_1.mapAsyncIterable)(iter, (v) => ({
+        ...v,
+        baseUrl: undefined,
+    }));
+    return yield* (0, async_iterable_1.combineAsyncIterables)(removeBaseUrlEmission(currIter), ...devRemoteIters.map(removeBaseUrlEmission), ...(staticRemotesIter ? [removeBaseUrlEmission(staticRemotesIter)] : []), (0, async_iterable_1.createAsyncIterable)(async ({ next, done }) => {
+        if (!options.isInitialHost) {
+            done();
+            return;
+        }
+        if (remotes.remotePorts.length === 0) {
+            devkit_1.logger.info(`NX All remotes started, server ready at http://localhost:${options.port}`);
+            next({ success: true, baseUrl: `http://localhost:${options.port}` });
+            done();
+            return;
+        }
+        try {
+            const portsToWaitFor = staticRemotesIter
+                ? [options.staticRemotesPort, ...remotes.remotePorts]
+                : [...remotes.remotePorts];
+            await Promise.all(portsToWaitFor.map((port) => (0, wait_for_port_open_1.waitForPortOpen)(port, {
+                retries: 480,
+                retryDelay: 2500,
+                host: 'localhost',
+            })));
+            devkit_1.logger.info(`NX All remotes started, server ready at http://localhost:${options.port}`);
+            next({ success: true, baseUrl: `http://localhost:${options.port}` });
+        }
+        catch {
+            throw new Error(`Timed out waiting for remote to start. Check above for any errors.`);
+        }
+        finally {
+            done();
+        }
+    }));
+}
+exports.default = moduleFederationDevServerExecutor;

package/src/{builders → executors}/module-federation-dev-server/schema.json

@@ -1,8 +1,7 @@
 {
-  "version": 2,
-  "outputCapture": "direct-nodejs",
   "$schema": "http://json-schema.org/draft-07/schema",
   "title": "Schema for Module Federation Dev Server",
+  "outputCapture": "direct-nodejs",
   "description": "The module-federation-dev-server executor is reserved exclusively for use with host Module Federation applications. It allows the user to specify which remote applications should be served with the host.",
   "type": "object",
   "presets": [
@@ -149,6 +148,13 @@
     }
   },
   "additionalProperties": false,
-  "anyOf": [{ "required": ["buildTarget"] }, { "required": ["browserTarget"] }],
+  "anyOf": [
+    {
+      "required": ["buildTarget"]
+    },
+    {
+      "required": ["browserTarget"]
+    }
+  ],
   "examplesFile": "../../../docs/module-federation-dev-server-examples.md"
 }

package/src/executors/utilities/buildable-libs.d.ts

@@ -0,0 +1,6 @@
+import { type ExecutorContext } from '@nx/devkit';
+import { type DependentBuildableProjectNode } from '@nx/js/src/utils/buildable-libs-utils';
+export declare function createTmpTsConfigForBuildableLibs(tsConfigPath: string, context: ExecutorContext): {
+    tsConfigPath: string;
+    dependencies: DependentBuildableProjectNode[];
+};

package/src/executors/{browser-esbuild/lib → utilities}/buildable-libs.js

@@ -1,16 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTmpTsConfigForBuildableLibs = void 0;
+const devkit_1 = require("@nx/devkit");
 const buildable_libs_utils_1 = require("@nx/js/src/utils/buildable-libs-utils");
 const path_1 = require("path");
-const devkit_1 = require("@nx/devkit");
-function createTmpTsConfigForBuildableLibs(tsConfigPath, context, options) {
+function createTmpTsConfigForBuildableLibs(tsConfigPath, context) {
     let dependencies;
-    const result = (0, buildable_libs_utils_1.calculateProjectDependencies)(options?.projectGraph ?? (0, devkit_1.readCachedProjectGraph)(), context.root, context.projectName, options?.target ?? context.targetName, context.configurationName);
+    const result = (0, buildable_libs_utils_1.calculateProjectDependencies)(context.projectGraph ?? (0, devkit_1.readCachedProjectGraph)(), context.root, context.projectName, context.targetName, context.configurationName);
     dependencies = result.dependencies;
     const tmpTsConfigPath = (0, buildable_libs_utils_1.createTmpTsConfig)((0, path_1.join)(context.root, tsConfigPath), context.root, result.target.data.root, dependencies);
     process.env.NX_TSCONFIG_PATH = tmpTsConfigPath;
-    // Angular EsBuild Builder appends the workspaceRoot to the config path, so remove it.
     const tmpTsConfigPathWithoutWorkspaceRoot = tmpTsConfigPath.replace(context.root, '');
     return { tsConfigPath: tmpTsConfigPathWithoutWorkspaceRoot, dependencies };
 }

package/src/executors/utilities/esbuild-extensions.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from 'esbuild';
+export type PluginSpec = {
+    path: string;
+    options: any;
+};
+export declare function loadPlugins(plugins: string[] | PluginSpec[] | undefined, tsConfig: string): Promise<Plugin[]>;

package/src/executors/utilities/esbuild-extensions.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadPlugins = void 0;
+const internal_1 = require("@nx/js/src/internal");
+const module_loader_1 = require("./module-loader");
+async function loadPlugins(plugins, tsConfig) {
+    if (!plugins?.length) {
+        return [];
+    }
+    const cleanupTranspiler = (0, internal_1.registerTsProject)(tsConfig);
+    try {
+        return await Promise.all(plugins.map((plugin) => loadPlugin(plugin)));
+    }
+    finally {
+        cleanupTranspiler();
+    }
+}
+exports.loadPlugins = loadPlugins;
+async function loadPlugin(pluginSpec) {
+    const pluginPath = typeof pluginSpec === 'string' ? pluginSpec : pluginSpec.path;
+    let plugin = await (0, module_loader_1.loadModule)(pluginPath);
+    if (typeof plugin === 'function') {
+        plugin =
+            typeof pluginSpec === 'object' ? plugin(pluginSpec.options) : plugin();
+    }
+    return plugin;
+}

package/src/executors/utilities/module-loader.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+export declare function loadModule<T = any>(path: string): Promise<T>;
+/**
+ * This uses a dynamic import to load a module which may be ESM.
+ * CommonJS code can load ESM code via a dynamic import. Unfortunately, TypeScript
+ * will currently, unconditionally downlevel dynamic import into a require call.
+ * require calls cannot load ESM code and will result in a runtime error. To workaround
+ * this, a Function constructor is used to prevent TypeScript from changing the dynamic import.
+ * Once TypeScript provides support for keeping the dynamic import this workaround can
+ * be dropped.
+ *
+ * @param modulePath The path of the module to load.
+ * @returns A Promise that resolves to the dynamically imported module.
+ */
+export declare function loadEsmModule<T>(modulePath: string | URL): Promise<T>;

package/src/executors/utilities/module-loader.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadEsmModule = exports.loadModule = void 0;
+const path_1 = require("path");
+const node_url_1 = require("node:url");
+async function loadModule(path) {
+    switch ((0, path_1.extname)(path)) {
+        case '.mjs': {
+            const result = await loadEsmModule((0, node_url_1.pathToFileURL)(path));
+            return result.default ?? result;
+        }
+        case '.cjs': {
+            const result = require(path);
+            return result.default ?? result;
+        }
+        default:
+            // it can be CommonJS or ESM, try both
+            try {
+                const result = require(path);
+                return result.default ?? result;
+            }
+            catch (e) {
+                if (e.code === 'ERR_REQUIRE_ESM') {
+                    const result = await loadEsmModule((0, node_url_1.pathToFileURL)(path));
+                    return result.default ?? result;
+                }
+                throw e;
+            }
+    }
+}
+exports.loadModule = loadModule;
+/**
+ * Lazily compiled dynamic import loader function.
+ */
+let load;
+/**
+ * This uses a dynamic import to load a module which may be ESM.
+ * CommonJS code can load ESM code via a dynamic import. Unfortunately, TypeScript
+ * will currently, unconditionally downlevel dynamic import into a require call.
+ * require calls cannot load ESM code and will result in a runtime error. To workaround
+ * this, a Function constructor is used to prevent TypeScript from changing the dynamic import.
+ * Once TypeScript provides support for keeping the dynamic import this workaround can
+ * be dropped.
+ *
+ * @param modulePath The path of the module to load.
+ * @returns A Promise that resolves to the dynamically imported module.
+ */
+function loadEsmModule(modulePath) {
+    load ??= new Function('modulePath', `return import(modulePath);`);
+    return load(modulePath);
+}
+exports.loadEsmModule = loadEsmModule;

package/src/executors/utilities/ng-compiler-cli.d.ts

@@ -1,15 +1 @@
-/// <reference types="node" />
 export declare function ngCompilerCli(): Promise<typeof import('@angular/compiler-cli')>;
-/**
- * This uses a dynamic import to load a module which may be ESM.
- * CommonJS code can load ESM code via a dynamic import. Unfortunately, TypeScript
- * will currently, unconditionally downlevel dynamic import into a require call.
- * require calls cannot load ESM code and will result in a runtime error. To workaround
- * this, a Function constructor is used to prevent TypeScript from changing the dynamic import.
- * Once TypeScript provides support for keeping the dynamic import this workaround can
- * be dropped.
- *
- * @param modulePath The path of the module to load.
- * @returns A Promise that resolves to the dynamically imported module.
- */
-export declare function loadEsmModule<T>(modulePath: string | URL): Promise<T>;

package/src/executors/utilities/ng-compiler-cli.js

@@ -1,28 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadEsmModule = exports.ngCompilerCli = void 0;
+exports.ngCompilerCli = void 0;
+const module_loader_1 = require("./module-loader");
 function ngCompilerCli() {
-    return loadEsmModule('@angular/compiler-cli');
+    return (0, module_loader_1.loadEsmModule)('@angular/compiler-cli');
 }
 exports.ngCompilerCli = ngCompilerCli;
-/**
- * Lazily compiled dynamic import loader function.
- */
-let load;
-/**
- * This uses a dynamic import to load a module which may be ESM.
- * CommonJS code can load ESM code via a dynamic import. Unfortunately, TypeScript
- * will currently, unconditionally downlevel dynamic import into a require call.
- * require calls cannot load ESM code and will result in a runtime error. To workaround
- * this, a Function constructor is used to prevent TypeScript from changing the dynamic import.
- * Once TypeScript provides support for keeping the dynamic import this workaround can
- * be dropped.
- *
- * @param modulePath The path of the module to load.
- * @returns A Promise that resolves to the dynamically imported module.
- */
-function loadEsmModule(modulePath) {
-    load ??= new Function('modulePath', `return import(modulePath);`);
-    return load(modulePath);
-}
-exports.loadEsmModule = loadEsmModule;

package/src/builders/module-federation-dev-server/module-federation-dev-server.impl.d.ts

@@ -1,5 +0,0 @@
-import type { Schema } from './schema';
-import { executeDevServerBuilder } from '../dev-server/dev-server.impl';
-export declare function executeModuleFederationDevServerBuilder(schema: Schema, context: import('@angular-devkit/architect').BuilderContext): ReturnType<typeof executeDevServerBuilder | any>;
-declare const _default: any;
-export default _default;