@nx/angular 0.0.0-pr-22179-271588f

package/src/generators/convert-to-with-mf/lib/write-new-webpack-config.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeNewWebpackConfig = void 0;
+const is_host_remote_config_1 = require("./is-host-remote-config");
+function writeNewWebpackConfig(ast, mfType, projectName) {
+    const webpackConfig = `const { withModuleFederation } = require('@nx/angular/module-federation');
+const config = require('./module-federation.config');
+module.exports = withModuleFederation(config);
+`;
+    let mfeConfig = '';
+    if (!mfType) {
+        mfeConfig = `
+        module.exports = {
+          name: '${projectName}',
+        };`;
+    }
+    else if (mfType === 'host') {
+        const remotes = hostRemotesToString(ast);
+        mfeConfig = `
+        module.exports = {
+          name: '${projectName}',
+          remotes: ${remotes},
+        };`;
+    }
+    else if (mfType === 'remote') {
+        const exposedModules = (0, is_host_remote_config_1.getExposedModulesFromRemote)(ast);
+        mfeConfig = `
+        module.exports = {
+          name: '${projectName}',
+          exposes: ${exposedModules},
+        };`;
+    }
+    else if (mfType === 'both') {
+        const remotes = hostRemotesToString(ast);
+        const exposedModules = (0, is_host_remote_config_1.getExposedModulesFromRemote)(ast);
+        mfeConfig = `
+    module.exports = {
+      name: '${projectName}',
+      remotes: ${remotes},
+      exposes: ${exposedModules},
+    };`;
+    }
+    return [webpackConfig, mfeConfig];
+}
+exports.writeNewWebpackConfig = writeNewWebpackConfig;
+function hostRemotesToString(ast) {
+    const remotes = (0, is_host_remote_config_1.getRemotesFromHost)(ast)
+        .reduce((acc, remotePair) => `['${remotePair[0]}', '${remotePair[1]}'], ${acc}`, '')
+        .trim();
+    return `[${remotes.endsWith(',') ? remotes.slice(0, -1) : remotes}]`;
+}

package/src/generators/convert-to-with-mf/schema.d.ts

@@ -0,0 +1,4 @@
+export interface Schema {
+  project: string;
+  skipFormat?: boolean;
+}

package/src/generators/convert-to-with-mf/schema.json

@@ -0,0 +1,33 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "ConvertToWithMFGenerator",
+  "cli": "nx",
+  "title": "Convert to withModuleFederation Generator Options Schema",
+  "type": "object",
+  "description": "Converts an old micro frontend configuration to use the new withModuleFederation helper. It will run successfully if the following conditions are met: \n - Is either a host or remote application \n - Shared npm package configurations have not been modified \n - Name used to identify the Micro Frontend application matches the project name \n\n{% callout type=\"warning\" title=\"Overrides\" %}This generator will overwrite your webpack config. If you have additional custom configuration in your config file, it will be lost!{% /callout %}.",
+  "additionalProperties": false,
+  "examples": [
+    {
+      "command": "nx g @nx/angular:convert-to-with-mf --project mf-app",
+      "description": "Convert a Module Federation Project using legacy webpack config to use the `withModuleFederation` helper."
+    }
+  ],
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "The name of the micro frontend project to migrate.",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "What micro frontend project would you like to migrate?",
+      "x-priority": "important"
+    },
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false,
+      "x-priority": "internal"
+    }
+  }
+}

package/src/generators/cypress-component-configuration/cypress-component-configuration.d.ts

@@ -0,0 +1,9 @@
+import { Tree } from '@nx/devkit';
+import { CypressComponentConfigSchema } from './schema';
+export declare function cypressComponentConfiguration(tree: Tree, options: CypressComponentConfigSchema): Promise<import("@nx/devkit").GeneratorCallback>;
+/**
+ * This is for cypress built in component testing, if you want to test with
+ * storybook + cypress then use the componentCypressGenerator instead.
+ */
+export declare function cypressComponentConfigurationInternal(tree: Tree, options: CypressComponentConfigSchema): Promise<import("@nx/devkit").GeneratorCallback>;
+export default cypressComponentConfiguration;

package/src/generators/cypress-component-configuration/cypress-component-configuration.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cypressComponentConfigurationInternal = exports.cypressComponentConfiguration = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const versions_1 = require("../../utils/versions");
+const component_test_1 = require("../component-test/component-test");
+const component_info_1 = require("../utils/storybook-ast/component-info");
+const entry_point_1 = require("../utils/storybook-ast/entry-point");
+const module_info_1 = require("../utils/storybook-ast/module-info");
+const update_app_editor_tsconfig_excluded_files_1 = require("../utils/update-app-editor-tsconfig-excluded-files");
+function cypressComponentConfiguration(tree, options) {
+    return cypressComponentConfigurationInternal(tree, {
+        ...options,
+    });
+}
+exports.cypressComponentConfiguration = cypressComponentConfiguration;
+/**
+ * This is for cypress built in component testing, if you want to test with
+ * storybook + cypress then use the componentCypressGenerator instead.
+ */
+async function cypressComponentConfigurationInternal(tree, options) {
+    const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    const { componentConfigurationGenerator: baseCyCTConfig } = (0, devkit_1.ensurePackage)('@nx/cypress', versions_1.nxVersion);
+    const installTask = await baseCyCTConfig(tree, {
+        project: options.project,
+        skipFormat: true,
+        addPlugin: false,
+        addExplicitTargets: true,
+    });
+    await configureCypressCT(tree, options);
+    await addFiles(tree, projectConfig, options);
+    if (projectConfig.projectType === 'application') {
+        (0, update_app_editor_tsconfig_excluded_files_1.updateAppEditorTsConfigExcludedFiles)(tree, projectConfig);
+    }
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return installTask;
+}
+exports.cypressComponentConfigurationInternal = cypressComponentConfigurationInternal;
+async function addFiles(tree, projectConfig, options) {
+    const componentFile = (0, devkit_1.joinPathFragments)(projectConfig.root, 'cypress', 'support', 'component.ts');
+    const { addMountDefinition } = await Promise.resolve().then(() => require('@nx/cypress/src/utils/config'));
+    const updatedCmpContents = await addMountDefinition(tree.read(componentFile, 'utf-8'));
+    tree.write(componentFile, `import { mount } from 'cypress/angular';\n${updatedCmpContents}`);
+    if (options.generateTests) {
+        const entryPoints = (0, entry_point_1.getProjectEntryPoints)(tree, options.project);
+        const componentInfo = [];
+        for (const entryPoint of entryPoints) {
+            const moduleFilePaths = (0, module_info_1.getModuleFilePaths)(tree, entryPoint);
+            componentInfo.push(...(0, component_info_1.getComponentsInfo)(tree, entryPoint, moduleFilePaths, options.project), ...(0, component_info_1.getStandaloneComponentsInfo)(tree, entryPoint));
+        }
+        for (const info of componentInfo) {
+            if (info === undefined) {
+                continue;
+            }
+            const componentDirFromProjectRoot = (0, path_1.relative)(projectConfig.root, (0, devkit_1.joinPathFragments)(info.moduleFolderPath, info.path));
+            await (0, component_test_1.componentTestGenerator)(tree, {
+                project: options.project,
+                componentName: info.name,
+                componentDir: componentDirFromProjectRoot,
+                componentFileName: info.componentFileName,
+                skipFormat: true,
+            });
+        }
+    }
+}
+async function configureCypressCT(tree, options) {
+    let found = { target: options.buildTarget, config: undefined };
+    if (!options.buildTarget) {
+        const { findBuildConfig } = await Promise.resolve().then(() => require('@nx/cypress/src/utils/find-target-options'));
+        found = await findBuildConfig(tree, {
+            project: options.project,
+            buildTarget: options.buildTarget,
+            validExecutorNames: new Set([
+                '@nx/angular:webpack-browser',
+                '@nrwl/angular:webpack-browser',
+                '@angular-devkit/build-angular:browser',
+            ]),
+        });
+        assertValidConfig(found?.config);
+    }
+    const ctConfigOptions = {};
+    const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    if (projectConfig.targets?.['component-test']?.executor ===
+        '@nx/cypress:cypress') {
+        projectConfig.targets['component-test'].options = {
+            ...projectConfig.targets['component-test'].options,
+            skipServe: true,
+            devServerTarget: found.target,
+        };
+        (0, devkit_1.updateProjectConfiguration)(tree, options.project, projectConfig);
+    }
+    else {
+        ctConfigOptions.buildTarget = found.target;
+    }
+    const { addDefaultCTConfig, getProjectCypressConfigPath } = await Promise.resolve().then(() => require('@nx/cypress/src/utils/config'));
+    const cypressConfigPath = getProjectCypressConfigPath(tree, projectConfig.root);
+    const updatedCyConfig = await addDefaultCTConfig(tree.read(cypressConfigPath, 'utf-8'), ctConfigOptions);
+    tree.write(cypressConfigPath, `import { nxComponentTestingPreset } from '@nx/angular/plugins/component-testing';\n${updatedCyConfig}`);
+}
+function assertValidConfig(config) {
+    if (!config) {
+        throw new Error('Unable to find a valid build configuration. Try passing in a target for an Angular app. --build-target=<project>:<target>[:<configuration>]');
+    }
+}
+exports.default = cypressComponentConfiguration;

package/src/generators/cypress-component-configuration/schema.d.ts

@@ -0,0 +1,6 @@
+export interface CypressComponentConfigSchema {
+  project: string;
+  generateTests: boolean;
+  skipFormat?: boolean;
+  buildTarget?: string;
+}

package/src/generators/cypress-component-configuration/schema.json

@@ -0,0 +1,40 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxAngularCypressComponentConfigurationGenerator",
+  "type": "object",
+  "cli": "nx",
+  "title": "Add Cypress component testing",
+  "description": "Add a Cypress component testing configuration to an existing project. Cypress v10.7.0 or higher is required.",
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "The name of the project to add cypress component testing configuration to",
+      "$default": {
+        "$source": "projectName"
+      },
+      "x-dropdown": "projects",
+      "x-prompt": "What project should we add Cypress component testing to?",
+      "x-priority": "important"
+    },
+    "generateTests": {
+      "type": "boolean",
+      "description": "Generate default component tests for existing components in the project",
+      "x-prompt": "Automatically generate tests for components declared in this project?",
+      "default": false
+    },
+    "buildTarget": {
+      "type": "string",
+      "description": "A build target used to configure Cypress component testing in the format of `project:target[:configuration]`. The build target should be an angular app. If not provided we will try to infer it from your projects usage.",
+      "pattern": "^[^:\\s]+:[^:\\s]+(:\\S+)?$",
+      "x-priority": "important"
+    },
+    "skipFormat": {
+      "type": "boolean",
+      "description": "Skip formatting files",
+      "default": false,
+      "x-priority": "internal"
+    }
+  },
+  "required": ["project"],
+  "examplesFile": "../../../docs/cypress-component-configuration-examples.md"
+}

package/src/generators/directive/directive.d.ts

@@ -0,0 +1,4 @@
+import type { Tree } from '@nx/devkit';
+import type { Schema } from './schema';
+export declare function directiveGenerator(tree: Tree, schema: Schema): Promise<void>;
+export default directiveGenerator;

package/src/generators/directive/directive.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.directiveGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+const utils_1 = require("../utils");
+const lib_1 = require("./lib");
+async function directiveGenerator(tree, schema) {
+    const options = await (0, lib_1.normalizeOptions)(tree, schema);
+    (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, 'files'), options.directory, {
+        selector: options.selector,
+        symbolName: options.symbolName,
+        fileName: options.fileName,
+        standalone: options.standalone,
+        tpl: '',
+    });
+    if (options.skipTests) {
+        const pathToSpecFile = (0, devkit_1.joinPathFragments)(options.directory, `${options.fileName}.spec.ts`);
+        tree.delete(pathToSpecFile);
+    }
+    if (!options.skipImport && !options.standalone) {
+        const modulePath = (0, utils_1.findModule)(tree, options.directory, options.module);
+        (0, utils_1.addToNgModule)(tree, options.directory, modulePath, options.name, options.symbolName, options.fileName, 'declarations', true, options.export);
+    }
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+}
+exports.directiveGenerator = directiveGenerator;
+exports.default = directiveGenerator;

package/src/generators/directive/files/__fileName__.spec.ts__tpl__

@@ -0,0 +1,8 @@
+import { <%= symbolName %> } from './<%= fileName %>';
+
+describe('<%= symbolName %>', () => {
+  it('should create an instance', () => {
+    const directive = new <%= symbolName %>();
+    expect(directive).toBeTruthy();
+  });
+});

package/src/generators/directive/files/__fileName__.ts__tpl__

@@ -0,0 +1,9 @@
+import { Directive } from '@angular/core';
+
+@Directive({
+  selector: '[<%= selector %>]'<% if(standalone) {%>,
+  standalone: true<%}%>
+})
+export class <%= symbolName %> {
+  constructor() {}
+}

package/src/generators/directive/lib/index.d.ts

@@ -0,0 +1 @@
+export * from './normalize-options';

package/src/generators/directive/lib/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./normalize-options"), exports);

package/src/generators/directive/lib/normalize-options.d.ts

@@ -0,0 +1,3 @@
+import type { Tree } from '@nx/devkit';
+import type { NormalizedSchema, Schema } from '../schema';
+export declare function normalizeOptions(tree: Tree, options: Schema): Promise<NormalizedSchema>;

package/src/generators/directive/lib/normalize-options.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeOptions = void 0;
+const devkit_1 = require("@nx/devkit");
+const selector_1 = require("../../utils/selector");
+const artifact_name_and_directory_utils_1 = require("@nx/devkit/src/generators/artifact-name-and-directory-utils");
+async function normalizeOptions(tree, options) {
+    const { artifactName: name, directory, fileName, filePath, project: projectName, } = await (0, artifact_name_and_directory_utils_1.determineArtifactNameAndDirectoryOptions)(tree, {
+        artifactType: 'directive',
+        callingGenerator: '@nx/angular:directive',
+        name: options.name,
+        directory: options.directory ?? options.path,
+        flat: options.flat,
+        nameAndDirectoryFormat: options.nameAndDirectoryFormat,
+        project: options.project,
+        suffix: 'directive',
+    });
+    const { className } = (0, devkit_1.names)(name);
+    const { className: suffixClassName } = (0, devkit_1.names)('directive');
+    const symbolName = `${className}${suffixClassName}`;
+    const { prefix } = (0, devkit_1.readProjectConfiguration)(tree, projectName);
+    const selector = options.selector ??
+        (0, selector_1.buildSelector)(name, options.prefix, prefix, 'propertyName');
+    (0, selector_1.validateHtmlSelector)(selector);
+    return {
+        ...options,
+        projectName,
+        name,
+        directory,
+        fileName,
+        filePath,
+        symbolName,
+        selector,
+        standalone: options.standalone ?? true,
+    };
+}
+exports.normalizeOptions = normalizeOptions;

package/src/generators/directive/schema.d.ts

@@ -0,0 +1,35 @@
+import { NameAndDirectoryFormat } from '@nx/devkit/src/generators/artifact-name-and-directory-utils';
+
+export interface Schema {
+  name: string;
+  directory?: string;
+  nameAndDirectoryFormat?: NameAndDirectoryFormat;
+  prefix?: string;
+  skipTests?: boolean;
+  skipImport?: boolean;
+  selector?: string;
+  standalone?: boolean;
+  module?: string;
+  export?: boolean;
+  skipFormat?: boolean;
+  /**
+   * @deprecated Provide the `directory` option instead and use the `as-provided` format. It will be removed in Nx v19.
+   */
+  flat?: boolean;
+  /**
+   * @deprecated Provide the `directory` option instead. It will be removed in Nx v19.
+   */
+  path?: string;
+  /**
+   * @deprecated Provide the `directory` option instead. The project will be determined from the directory provided. It will be removed in Nx v19.
+   */
+  project?: string;
+}
+
+export interface NormalizedSchema extends Schema {
+  directory: string;
+  filePath: string;
+  fileName: string;
+  symbolName: string;
+  projectName: string;
+}

package/src/generators/directive/schema.json

@@ -0,0 +1,96 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "GeneratorAngularDirective",
+  "cli": "nx",
+  "title": "Nx Angular Directive Options Schema",
+  "type": "object",
+  "description": "Creates a new Angular directive.",
+  "additionalProperties": false,
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "The name of the new directive.",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "What name would you like to use for the directive?"
+    },
+    "directory": {
+      "type": "string",
+      "description": "The directory at which to create the directive file. When `--nameAndDirectoryFormat=as-provided`, it will be relative to the current working directory. Otherwise, it will be relative to the workspace root.",
+      "aliases": ["dir", "path"],
+      "x-priority": "important"
+    },
+    "nameAndDirectoryFormat": {
+      "description": "Whether to generate the directive in the directory as provided, relative to the current working directory and ignoring the project (`as-provided`) or generate it using the project and directory relative to the workspace root (`derived`).",
+      "type": "string",
+      "enum": ["as-provided", "derived"]
+    },
+    "project": {
+      "type": "string",
+      "description": "The name of the project.",
+      "$default": {
+        "$source": "projectName"
+      },
+      "x-dropdown": "projects",
+      "x-deprecated": "Provide the `directory` option instead and use the `as-provided` format. The project will be determined from the directory provided. It will be removed in Nx v19."
+    },
+    "prefix": {
+      "type": "string",
+      "description": "A prefix to apply to generated selectors.",
+      "alias": "p",
+      "oneOf": [
+        {
+          "maxLength": 0
+        },
+        {
+          "minLength": 1,
+          "format": "html-selector"
+        }
+      ]
+    },
+    "skipTests": {
+      "type": "boolean",
+      "description": "Do not create \"spec.ts\" test files for the new class.",
+      "default": false
+    },
+    "skipImport": {
+      "type": "boolean",
+      "description": "Do not import this directive into the owning NgModule.",
+      "default": false
+    },
+    "selector": {
+      "type": "string",
+      "format": "html-selector",
+      "description": "The HTML selector to use for this directive."
+    },
+    "standalone": {
+      "description": "Whether the generated directive is standalone.",
+      "type": "boolean",
+      "default": true
+    },
+    "flat": {
+      "type": "boolean",
+      "description": "When true (the default), creates the new files at the top level of the current project.",
+      "default": true,
+      "x-deprecated": "Provide the `directory` option instead and use the `as-provided` format. It will be removed in Nx v19."
+    },
+    "module": {
+      "type": "string",
+      "description": "The filename of the declaring NgModule.",
+      "alias": "m"
+    },
+    "export": {
+      "type": "boolean",
+      "default": false,
+      "description": "The declaring NgModule exports this directive."
+    },
+    "skipFormat": {
+      "type": "boolean",
+      "default": false,
+      "description": "Skip formatting of files."
+    }
+  },
+  "required": ["name"]
+}

package/src/generators/federate-module/federate-module.d.ts

@@ -0,0 +1,4 @@
+import { type Tree } from '@nx/devkit';
+import { type Schema } from './schema';
+export declare function federateModuleGenerator(tree: Tree, schema: Schema): Promise<import("@nx/devkit").GeneratorCallback>;
+export default federateModuleGenerator;

package/src/generators/federate-module/federate-module.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.federateModuleGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+const lib_1 = require("./lib");
+async function federateModuleGenerator(tree, schema) {
+    if (!tree.exists(schema.path)) {
+        throw new Error((0, devkit_1.stripIndents) `The "path" provided  does not exist. Please verify the path is correct and pointing to a file that exists in the workspace.
+    
+    Path: ${schema.path}`);
+    }
+    schema.standalone = schema.standalone ?? true;
+    const { tasks, projectRoot, remoteName } = await (0, lib_1.addRemote)(tree, schema);
+    (0, lib_1.addFileToRemoteTsconfig)(tree, remoteName, schema.path);
+    (0, lib_1.addPathToExposes)(tree, {
+        projectPath: projectRoot,
+        modulePath: schema.path,
+        moduleName: schema.name,
+    });
+    (0, lib_1.addPathToTsConfig)(tree, {
+        remoteName,
+        moduleName: schema.name,
+        pathToFile: schema.path,
+    });
+    if (!schema.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    devkit_1.logger.info(`✅️ Updated module federation config.
+    Now you can use the module from your remote app like this:
+
+    Static import:
+    import { MyComponent } from '${remoteName}/${schema.name}';
+    
+    Dynamic import:
+    import('${remoteName}/${schema.name}').then((m) => m.MyComponent);
+  `);
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+exports.federateModuleGenerator = federateModuleGenerator;
+exports.default = federateModuleGenerator;

package/src/generators/federate-module/lib/add-file-to-remote-tsconfig.d.ts

@@ -0,0 +1,2 @@
+import { type Tree } from '@nx/devkit';
+export declare function addFileToRemoteTsconfig(tree: Tree, remoteName: string, pathToExpose: string): void;

package/src/generators/federate-module/lib/add-file-to-remote-tsconfig.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addFileToRemoteTsconfig = void 0;
+const devkit_1 = require("@nx/devkit");
+function addFileToRemoteTsconfig(tree, remoteName, pathToExpose) {
+    const remote = (0, devkit_1.readProjectConfiguration)(tree, remoteName);
+    (0, devkit_1.updateJson)(tree, remote.targets.build.options.tsConfig, (json) => ({
+        ...json,
+        files: [
+            ...json.files,
+            (0, devkit_1.joinPathFragments)((0, devkit_1.offsetFromRoot)(remote.root), pathToExpose),
+        ],
+    }));
+}
+exports.addFileToRemoteTsconfig = addFileToRemoteTsconfig;

package/src/generators/federate-module/lib/add-path-to-exposes.d.ts

@@ -0,0 +1,8 @@
+import { type Tree } from '@nx/devkit';
+type AddPathToExposesOptions = {
+    projectPath: string;
+    moduleName: string;
+    modulePath: string;
+};
+export declare function addPathToExposes(tree: Tree, { projectPath, moduleName, modulePath }: AddPathToExposesOptions): void;
+export {};

package/src/generators/federate-module/lib/add-path-to-exposes.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addPathToExposes = void 0;
+const devkit_1 = require("@nx/devkit");
+const ensure_typescript_1 = require("@nx/js/src/utils/typescript/ensure-typescript");
+let tsModule;
+function addPathToExposes(tree, { projectPath, moduleName, modulePath }) {
+    const moduleFederationConfigPath = (0, devkit_1.joinPathFragments)(projectPath, tree.exists((0, devkit_1.joinPathFragments)(projectPath, 'module-federation.config.ts'))
+        ? 'module-federation.config.ts'
+        : 'module-federation.config.js');
+    updateExposesProperty(tree, moduleFederationConfigPath, moduleName, modulePath);
+}
+exports.addPathToExposes = addPathToExposes;
+function updateExposesProperty(tree, moduleFederationConfigPath, moduleName, modulePath) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const fileContent = tree.read(moduleFederationConfigPath, 'utf-8');
+    const source = tsModule.createSourceFile(moduleFederationConfigPath, fileContent, tsModule.ScriptTarget.ES2015, true);
+    const exposesObject = findExposes(source);
+    if (!exposesObject)
+        return;
+    const newEntry = createObjectEntry(moduleName, modulePath);
+    const updatedSourceFile = updateExposesPropertyinAST(source, exposesObject, newEntry);
+    writeToConfig(tree, moduleFederationConfigPath, source, updatedSourceFile);
+}
+function findExposes(sourceFile) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    let exposesObject = null;
+    const visit = (node) => {
+        if (tsModule.isPropertyAssignment(node) &&
+            tsModule.isIdentifier(node.name) &&
+            node.name.text === 'exposes' &&
+            tsModule.isObjectLiteralExpression(node.initializer)) {
+            exposesObject = node.initializer;
+        }
+        else {
+            tsModule.forEachChild(node, visit);
+        }
+    };
+    tsModule.forEachChild(sourceFile, visit);
+    return exposesObject;
+}
+// Create a new property assignment
+function createObjectEntry(moduleName, modulePath) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    return tsModule.factory.createPropertyAssignment(tsModule.factory.createStringLiteral(`./${moduleName}`, true), tsModule.factory.createStringLiteral(modulePath, true));
+}
+// Update the exposes property in the AST
+function updateExposesPropertyinAST(source, exposesObject, newEntry) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const updatedExposes = tsModule.factory.updateObjectLiteralExpression(exposesObject, [...exposesObject.properties, newEntry]);
+    const transform = (context) => {
+        const visit = (node) => {
+            // Comparing nodes indirectly to ensure type compatibility. You must ensure that the nodes are identical.
+            return tsModule.isObjectLiteralExpression(node) && node === exposesObject
+                ? updatedExposes
+                : tsModule.visitEachChild(node, visit, context);
+        };
+        return (node) => tsModule.visitNode(node, visit);
+    };
+    return tsModule.transform(source, [transform]).transformed[0];
+}
+// Write the updated AST to the file (module-federation.config.js)
+function writeToConfig(tree, filename, source, updatedSourceFile) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const printer = tsModule.createPrinter();
+    const update = printer.printNode(tsModule.EmitHint.Unspecified, updatedSourceFile, source);
+    tree.write(filename, update);
+}