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

package/src/generators/component-story/files/tsx/__componentFileName__.stories.tsx__tmpl__

@@ -0,0 +1,36 @@
+import type { Meta, StoryObj } from '@storybook/react';
+import { <%= componentName %>  } from './<%= componentImportFileName %>';
+<% if ( interactionTests ) { %>
+import { within } from '@storybook/testing-library';
+import { expect } from '@storybook/jest';
+<% } %>
+
+const meta: Meta<typeof <%= componentName %>> = {
+  component: <%= componentName %>,
+  title: '<%= componentName %>',<% if ( argTypes && argTypes.length > 0 ) { %> 
+  argTypes: {<% for (let argType of argTypes) { %>
+    <%= argType.name %>: { <%- argType.type %> : "<%- argType.actionText %>" },<% } %>
+}
+   <% } %> 
+};
+export default meta;
+type Story = StoryObj<typeof <%= componentName %>>;
+
+
+export const Primary = {
+  args: {<% for (let prop of props) { %>
+    <%= prop.name %>:  <%- prop.defaultValue %>,<% } %>
+  },
+};
+
+<% if ( interactionTests ) { %>
+export const Heading: Story = {
+  args: {<% for (let prop of props) { %>
+    <%= prop.name %>:  <%- prop.defaultValue %>,<% } %>
+  },
+  play: async ({ canvasElement }) => {
+    const canvas = within(canvasElement);
+    expect(canvas.getByText(/Welcome to <%=componentName%>!/gi)).toBeTruthy();
+  },
+};
+<% } %>

package/src/generators/component-story/schema.json

@@ -0,0 +1,42 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "cli": "nx",
+  "$id": "NxReactComponentStory",
+  "title": "Create component story",
+  "description": "Generate storybook story for a react component.",
+  "type": "object",
+  "properties": {
+    "project": {
+      "type": "string",
+      "aliases": ["name", "projectName"],
+      "description": "The project where to add the components.",
+      "examples": ["shared-ui-component"],
+      "$default": {
+        "$source": "projectName",
+        "index": 0
+      },
+      "x-prompt": "What's name of the project where the component lives?",
+      "x-priority": "important"
+    },
+    "componentPath": {
+      "type": "string",
+      "description": "Relative path to the component file from the library root.",
+      "examples": ["lib/components"],
+      "x-prompt": "What's path of the component relative to the project's lib root?",
+      "x-priority": "important"
+    },
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false,
+      "x-priority": "internal"
+    },
+    "interactionTests": {
+      "type": "boolean",
+      "description": "Set up Storybook interaction tests.",
+      "default": true,
+      "x-priority": "important"
+    }
+  },
+  "required": ["project", "componentPath"]
+}

package/src/generators/component-test/component-test.d.ts

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

package/src/generators/component-test/component-test.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.componentTestGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const ast_utils_1 = require("../../utils/ast-utils");
+const component_props_1 = require("../../utils/component-props");
+const versions_1 = require("../../utils/versions");
+const ensure_typescript_1 = require("@nx/js/src/utils/typescript/ensure-typescript");
+let tsModule;
+async function componentTestGenerator(tree, options) {
+    (0, devkit_1.ensurePackage)('@nx/cypress', versions_1.nxVersion);
+    const { assertMinimumCypressVersion } = await Promise.resolve().then(() => require('@nx/cypress/src/utils/cypress-version'));
+    assertMinimumCypressVersion(10);
+    // normalize any windows paths
+    options.componentPath = options.componentPath.replace(/\\/g, '/');
+    const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    const normalizedPath = options.componentPath.startsWith(projectConfig.sourceRoot)
+        ? (0, path_1.relative)(projectConfig.sourceRoot, options.componentPath)
+        : options.componentPath;
+    const componentPath = (0, devkit_1.joinPathFragments)(projectConfig.sourceRoot, normalizedPath);
+    if (tree.exists(componentPath)) {
+        generateSpecsForComponents(tree, componentPath);
+    }
+}
+exports.componentTestGenerator = componentTestGenerator;
+function generateSpecsForComponents(tree, filePath) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const sourceFile = tsModule.createSourceFile(filePath, tree.read(filePath, 'utf-8'), tsModule.ScriptTarget.Latest, true);
+    const cmpNodes = (0, ast_utils_1.findExportDeclarationsForJsx)(sourceFile);
+    const componentDir = (0, path_1.dirname)(filePath);
+    const ext = (0, path_1.extname)(filePath);
+    const fileName = (0, path_1.basename)(filePath, ext);
+    if (tree.exists((0, devkit_1.joinPathFragments)(componentDir, `${fileName}.cy${ext}`))) {
+        return;
+    }
+    const defaultExport = (0, ast_utils_1.getComponentNode)(sourceFile);
+    if (cmpNodes?.length) {
+        const components = cmpNodes.map((cmp) => {
+            const defaults = (0, component_props_1.getDefaultsForComponent)(sourceFile, cmp);
+            const isDefaultExport = defaultExport
+                ? defaultExport.name.text === cmp.name.text
+                : false;
+            return {
+                isDefaultExport,
+                props: [...defaults.props, ...defaults.argTypes],
+                name: cmp.name.text,
+                typeName: defaults.propsTypeName,
+            };
+        });
+        const namedImports = components
+            .reduce((imports, cmp) => {
+            if (cmp.typeName) {
+                imports.push(cmp.typeName);
+            }
+            if (cmp.isDefaultExport) {
+                return imports;
+            }
+            imports.push(cmp.name);
+            return imports;
+        }, [])
+            .join(', ');
+        const namedImportStatement = namedImports.length > 0 ? `, { ${namedImports} }` : '';
+        (0, devkit_1.generateFiles)(tree, (0, path_1.join)(__dirname, 'files'), componentDir, {
+            fileName,
+            components,
+            importStatement: defaultExport
+                ? `import ${defaultExport.name.text}${namedImportStatement} from './${fileName}'`
+                : `import { ${namedImports} } from './${fileName}'`,
+            ext,
+        });
+    }
+}
+exports.default = componentTestGenerator;

package/src/generators/component-test/files/__fileName__.cy__ext__

@@ -0,0 +1,21 @@
+import * as React from 'react'
+<%- importStatement %>
+
+<% for (let cmp of components) { %>
+describe(<%= cmp.name %>.name, () => {<% if (cmp.typeName) { %>
+  let props: <%= cmp.typeName%>;
+
+  beforeEach(() => {
+    props = {<% for (let prop of cmp.props) { %>
+      <%- prop.name %>: <% if(prop.type === 'action') { %>undefined<% } else { %><%- prop.defaultValue %>,<% } %><% }%>
+    }
+  })
+
+  it('renders', () => {
+    cy.mount(<<%= cmp.name %> {...props}/>)
+  })<% } else { %>
+  it('renders', () => {
+    cy.mount(<<%= cmp.name %> />)
+  })<% } %>
+})
+<% } %>

package/src/generators/component-test/schema.d.ts

@@ -0,0 +1,4 @@
+export interface ComponentTestSchema {
+    project: string;
+    componentPath: string;
+}

package/src/generators/component-test/schema.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/generators/component-test/schema.json

@@ -0,0 +1,31 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "cli": "nx",
+  "$id": "NxReactCypressComponentTest",
+  "title": "Add Cypress component test",
+  "description": "Add a Cypress component test for a component.",
+  "type": "object",
+  "examples": [
+    {
+      "command": "nx g @nx/react:component-test --project=my-react-project --component-path=src/lib/fancy-component.tsx",
+      "description": "Create a cypress component test for FancyComponent"
+    }
+  ],
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "The name of the project the component is apart of",
+      "x-dropdown": "projects",
+      "x-prompt": "What project is this component apart of?",
+      "x-priority": "important"
+    },
+    "componentPath": {
+      "type": "string",
+      "description": "Path to component, from the project source root",
+      "x-prompt": "What is the path to the component?",
+      "x-priority": "important"
+    }
+  },
+  "required": ["project", "componentPath"],
+  "examplesFile": "../../../docs/component-test-examples.md"
+}

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

@@ -0,0 +1,10 @@
+import { Tree } from '@nx/devkit';
+import { CypressComponentConfigurationSchema } from './schema.d';
+export declare function cypressComponentConfigGenerator(tree: Tree, options: CypressComponentConfigurationSchema): Promise<import("@nx/devkit").GeneratorCallback>;
+/**
+ * This is for using cypresses own Component testing, if you want to use test
+ * storybook components then use componentCypressGenerator instead.
+ *
+ */
+export declare function cypressComponentConfigGeneratorInternal(tree: Tree, options: CypressComponentConfigurationSchema): Promise<import("@nx/devkit").GeneratorCallback>;
+export default cypressComponentConfigGenerator;

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cypressComponentConfigGeneratorInternal = exports.cypressComponentConfigGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+const versions_1 = require("../../utils/versions");
+const add_files_1 = require("./lib/add-files");
+const ct_utils_1 = require("../../utils/ct-utils");
+function cypressComponentConfigGenerator(tree, options) {
+    return cypressComponentConfigGeneratorInternal(tree, {
+        addPlugin: false,
+        ...options,
+    });
+}
+exports.cypressComponentConfigGenerator = cypressComponentConfigGenerator;
+/**
+ * This is for using cypresses own Component testing, if you want to use test
+ * storybook components then use componentCypressGenerator instead.
+ *
+ */
+async function cypressComponentConfigGeneratorInternal(tree, options) {
+    const { componentConfigurationGenerator: baseCyCtConfig } = (0, devkit_1.ensurePackage)('@nx/cypress', versions_1.nxVersion);
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const addPlugin = process.env.NX_ADD_PLUGINS !== 'false' &&
+        nxJson.useInferencePlugins !== false;
+    options.addPlugin ??= addPlugin;
+    const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    const installTask = await baseCyCtConfig(tree, {
+        project: options.project,
+        skipFormat: true,
+        jsx: true,
+        addPlugin: options.addPlugin,
+    });
+    const found = await (0, ct_utils_1.configureCypressCT)(tree, {
+        project: options.project,
+        buildTarget: options.buildTarget,
+        bundler: options.bundler,
+        validExecutorNames: new Set([
+            '@nx/webpack:webpack',
+            '@nx/vite:build',
+            '@nrwl/webpack:webpack',
+            '@nrwl/vite:build',
+        ]),
+    });
+    await (0, add_files_1.addFiles)(tree, projectConfig, options, found);
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return installTask;
+}
+exports.cypressComponentConfigGeneratorInternal = cypressComponentConfigGeneratorInternal;
+exports.default = cypressComponentConfigGenerator;

package/src/generators/cypress-component-configuration/lib/add-files.d.ts

@@ -0,0 +1,4 @@
+import { ProjectConfiguration, Tree } from '@nx/devkit';
+import type { CypressComponentConfigurationSchema } from '../schema';
+import { FoundTarget } from '@nx/cypress/src/utils/find-target-options';
+export declare function addFiles(tree: Tree, projectConfig: ProjectConfiguration, options: CypressComponentConfigurationSchema, found: FoundTarget): Promise<void>;

package/src/generators/cypress-component-configuration/lib/add-files.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addFiles = void 0;
+const devkit_1 = require("@nx/devkit");
+const versions_1 = require("nx/src/utils/versions");
+const component_test_1 = require("../../component-test/component-test");
+const ct_utils_1 = require("../../../utils/ct-utils");
+async function addFiles(tree, projectConfig, options, found) {
+    // must dyanmicaly import to prevent packages not using cypress from erroring out
+    // when importing react
+    const { addMountDefinition, addDefaultCTConfig } = await Promise.resolve().then(() => require('@nx/cypress/src/utils/config'));
+    // Specifically undefined to allow Remix workaround of passing an empty string
+    const actualBundler = await (0, ct_utils_1.getActualBundler)(tree, options, found);
+    if (options.bundler && options.bundler !== actualBundler) {
+        devkit_1.logger.warn(`You have specified ${options.bundler} as the bundler but this project is configured to use ${actualBundler}.
+      This may cause errors. If you are seeing errors, try removing the --bundler option.`);
+    }
+    const bundlerToUse = options.bundler ?? actualBundler;
+    const commandFile = (0, devkit_1.joinPathFragments)(projectConfig.root, 'cypress', 'support', 'component.ts');
+    const updatedCommandFile = await addMountDefinition(tree.read(commandFile, 'utf-8'));
+    tree.write(commandFile, `import { mount } from 'cypress/react18';\n${updatedCommandFile}`);
+    if (options.bundler === 'webpack' ||
+        (!options.bundler && actualBundler === 'webpack')) {
+        (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { '@nx/webpack': versions_1.nxVersion });
+    }
+    if (options.bundler === 'vite' ||
+        (!options.bundler && actualBundler === 'vite')) {
+        (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { '@nx/vite': versions_1.nxVersion });
+    }
+    if (options.generateTests) {
+        const filePaths = [];
+        (0, devkit_1.visitNotIgnoredFiles)(tree, projectConfig.sourceRoot, (filePath) => {
+            if ((0, ct_utils_1.isComponent)(tree, filePath)) {
+                filePaths.push(filePath);
+            }
+        });
+        for (const filePath of filePaths) {
+            await (0, component_test_1.componentTestGenerator)(tree, {
+                project: options.project,
+                componentPath: filePath,
+            });
+        }
+    }
+}
+exports.addFiles = addFiles;

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

@@ -0,0 +1,8 @@
+export interface CypressComponentConfigurationSchema {
+  project: string;
+  generateTests: boolean;
+  skipFormat?: boolean;
+  buildTarget?: string;
+  bundler?: 'webpack' | 'vite';
+  addPlugin?: boolean;
+}

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

@@ -0,0 +1,54 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "cli": "nx",
+  "$id": "NxReactCypressComponentTestConfiguration",
+  "title": "Add Cypress component testing",
+  "description": "Add a Cypress component testing configuration to an existing project.",
+  "type": "object",
+  "examples": [
+    {
+      "command": "nx g @nx/react:cypress-component-configuration --project=my-react-project",
+      "description": "Add component testing to your react project"
+    },
+    {
+      "command": "nx g @nx/react:cypress-component-configuration --project=my-react-project --generate-tests",
+      "description": "Add component testing to your react project and generate component tests for your existing components"
+    }
+  ],
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "The name of the project to add cypress component testing configuration to",
+      "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,
+      "x-priority": "important"
+    },
+    "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 from a React app. If not provided we will try to infer it from your projects usage.",
+      "pattern": "^[^:\\s]+:[^:\\s]+(:\\S+)?$"
+    },
+    "skipFormat": {
+      "type": "boolean",
+      "description": "Skip formatting files",
+      "default": false,
+      "x-priority": "internal"
+    },
+    "bundler": {
+      "description": "The bundler to use for Cypress Component Testing.",
+      "type": "string",
+      "enum": ["vite", "webpack"],
+      "hidden": true,
+      "x-priority": "internal"
+    }
+  },
+  "required": ["project"],
+  "examplesFile": "../../../docs/cypress-component-configuration-examples.md"
+}

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

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

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

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.federateModuleGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+const remote_1 = require("../remote/remote");
+const utils_1 = require("./lib/utils");
+const project_name_and_root_utils_1 = require("@nx/devkit/src/generators/project-name-and-root-utils");
+const js_1 = require("@nx/js");
+async function federateModuleGenerator(tree, schema) {
+    // Check if the file exists
+    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}`);
+    }
+    const tasks = [];
+    // Check remote exists
+    const remote = (0, utils_1.checkRemoteExists)(tree, schema.remote);
+    let projectRoot, remoteName;
+    if (!remote) {
+        // create remote
+        const remoteGenerator = await (0, remote_1.remoteGeneratorInternal)(tree, {
+            name: schema.remote,
+            directory: schema.remoteDirectory,
+            e2eTestRunner: schema.e2eTestRunner,
+            skipFormat: schema.skipFormat,
+            linter: schema.linter,
+            style: schema.style,
+            unitTestRunner: schema.unitTestRunner,
+            host: schema.host,
+            projectNameAndRootFormat: schema.projectNameAndRootFormat ?? 'derived',
+        });
+        tasks.push(remoteGenerator);
+        const { projectName, projectRoot: remoteRoot } = await (0, project_name_and_root_utils_1.determineProjectNameAndRootOptions)(tree, {
+            name: schema.remote,
+            directory: schema.remoteDirectory,
+            projectType: 'application',
+            projectNameAndRootFormat: schema.projectNameAndRootFormat ?? 'derived',
+            callingGenerator: '@nx/react:federate-module',
+        });
+        projectRoot = remoteRoot;
+        remoteName = projectName;
+    }
+    else {
+        projectRoot = remote.root;
+        remoteName = remote.name;
+    }
+    // add path to exposes property
+    (0, utils_1.addPathToExposes)(tree, projectRoot, schema.name, schema.path);
+    // Add new path to tsconfig
+    const rootJSON = (0, devkit_1.readJson)(tree, (0, js_1.getRootTsConfigPathInTree)(tree));
+    if (!rootJSON?.compilerOptions?.paths[`${remoteName}/${schema.name}`]) {
+        (0, js_1.addTsConfigPath)(tree, `${remoteName}/${schema.name}`, [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 host app like this:
+
+    Static import:
+    import { MyComponent } from '${remoteName}/${schema.name}';
+    
+    Dynamic import:
+    import('${remoteName}/${schema.name}').then((m) => m.${schema.name});
+  `);
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+exports.federateModuleGenerator = federateModuleGenerator;
+exports.default = federateModuleGenerator;

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

@@ -0,0 +1,23 @@
+import { Tree } from '@nx/devkit';
+import type { SourceFile, ObjectLiteralExpression, PropertyAssignment } from 'typescript';
+/**
+ * Adds a Module Federation path to the exposes property of the module federation config
+ * The assumption here is made the we will only update a TypeScript Module Federation file namely 'module-federation.config.js'
+ * @param tree Tree for the workspace
+ * @param projectPath Project path relative to the workspace
+ * @param moduleName The name of the module to expose
+ * @param modulePath The path to the module to expose (e.g. './src/my-lib/my-lib.ts')
+ */
+export declare function addPathToExposes(tree: Tree, projectPath: string, moduleName: string, modulePath: string): void;
+/**
+ * @param tree The workspace tree
+ * @param remoteName The name of the remote to check
+ * @returns Remote ProjectConfig if it exists, false otherwise
+ */
+export declare function checkRemoteExists(tree: Tree, remoteName: string): false | import("@nx/devkit").ProjectConfiguration;
+export declare function getRemote(tree: Tree, remoteName: string): import("@nx/devkit").ProjectConfiguration;
+export declare function findExposes(sourceFile: SourceFile): ObjectLiteralExpression;
+export declare function createObjectEntry(moduleName: string, modulePath: string): PropertyAssignment;
+export declare function updateExposesPropertyinAST(source: SourceFile, exposesObject: ObjectLiteralExpression, newEntry: PropertyAssignment): SourceFile;
+export declare function writeToConfig(tree: Tree, filename: string, source: SourceFile, updatedSourceFile: SourceFile): void;
+export declare function updateExposesProperty(tree: Tree, filename: string, moduleName: string, modulePath: string): void;

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

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateExposesProperty = exports.writeToConfig = exports.updateExposesPropertyinAST = exports.createObjectEntry = exports.findExposes = exports.getRemote = exports.checkRemoteExists = exports.addPathToExposes = void 0;
+const devkit_1 = require("@nx/devkit");
+const ensure_typescript_1 = require("@nx/js/src/utils/typescript/ensure-typescript");
+let tsModule;
+if (!tsModule) {
+    tsModule = (0, ensure_typescript_1.ensureTypescript)();
+}
+/**
+ * Adds a Module Federation path to the exposes property of the module federation config
+ * The assumption here is made the we will only update a TypeScript Module Federation file namely 'module-federation.config.js'
+ * @param tree Tree for the workspace
+ * @param projectPath Project path relative to the workspace
+ * @param moduleName The name of the module to expose
+ * @param modulePath The path to the module to expose (e.g. './src/my-lib/my-lib.ts')
+ */
+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;
+/**
+ * @param tree The workspace tree
+ * @param remoteName The name of the remote to check
+ * @returns Remote ProjectConfig if it exists, false otherwise
+ */
+function checkRemoteExists(tree, remoteName) {
+    const remote = getRemote(tree, remoteName);
+    if (!remote)
+        return false;
+    const hasModuleFederationConfig = tree.exists((0, devkit_1.joinPathFragments)(remote.root, 'module-federation.config.js')) ||
+        tree.exists((0, devkit_1.joinPathFragments)(remote.root, 'module-federation.config.ts'));
+    return hasModuleFederationConfig ? remote : false;
+}
+exports.checkRemoteExists = checkRemoteExists;
+function getRemote(tree, remoteName) {
+    const projects = (0, devkit_1.getProjects)(tree);
+    const remote = projects.get(remoteName);
+    return remote;
+}
+exports.getRemote = getRemote;
+// Check if the exposes property exists in the AST
+function findExposes(sourceFile) {
+    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;
+}
+exports.findExposes = findExposes;
+// Create a new property assignment
+function createObjectEntry(moduleName, modulePath) {
+    return tsModule.factory.createPropertyAssignment(tsModule.factory.createStringLiteral(`./${moduleName}`, true), tsModule.factory.createStringLiteral(modulePath, true));
+}
+exports.createObjectEntry = createObjectEntry;
+// Update the exposes property in the AST
+function updateExposesPropertyinAST(source, exposesObject, newEntry) {
+    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];
+}
+exports.updateExposesPropertyinAST = updateExposesPropertyinAST;
+// Write the updated AST to the file (module-federation.config.js)
+function writeToConfig(tree, filename, source, updatedSourceFile) {
+    const printer = tsModule.createPrinter();
+    const update = printer.printNode(tsModule.EmitHint.Unspecified, updatedSourceFile, source);
+    tree.write(filename, update);
+}
+exports.writeToConfig = writeToConfig;
+function updateExposesProperty(tree, filename, moduleName, modulePath) {
+    const fileContent = tree.read(filename).toString();
+    const source = tsModule.createSourceFile(filename, 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, filename, source, updatedSourceFile);
+}
+exports.updateExposesProperty = updateExposesProperty;

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

@@ -0,0 +1,13 @@
+export interface Schema {
+  name: string;
+  path: string;
+  remote: string;
+  remoteDirectory?: string;
+  projectNameAndRootFormat?: ProjectNameAndRootFormat;
+  e2eTestRunner?: 'cypress' | 'playwright' | 'none';
+  host?: string;
+  linter?: Linter;
+  skipFormat?: boolean;
+  style?: SupportedStyles;
+  unitTestRunner?: 'jest' | 'vitest' | 'none';
+}