@nx/angular 17.0.0-beta.2 → 17.0.0-beta.5

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);
+}

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

@@ -0,0 +1,8 @@
+import { type Tree } from '@nx/devkit';
+type AddPathToTsConfigOptions = {
+    remoteName: string;
+    moduleName: string;
+    pathToFile: string;
+};
+export declare function addPathToTsConfig(tree: Tree, { remoteName, moduleName, pathToFile }: AddPathToTsConfigOptions): void;
+export {};

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addPathToTsConfig = void 0;
+const devkit_1 = require("@nx/devkit");
+const js_1 = require("@nx/js");
+function addPathToTsConfig(tree, { remoteName, moduleName, pathToFile }) {
+    const rootTsConfig = (0, devkit_1.readJson)(tree, (0, js_1.getRootTsConfigPathInTree)(tree));
+    if (!rootTsConfig.compilerOptions?.paths[`${remoteName}/${moduleName}`]) {
+        (0, js_1.addTsConfigPath)(tree, `${remoteName}/${moduleName}`, [pathToFile]);
+    }
+}
+exports.addPathToTsConfig = addPathToTsConfig;

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

@@ -0,0 +1,7 @@
+import { GeneratorCallback, type Tree } from '@nx/devkit';
+import { type Schema } from '../schema';
+export declare function addRemote(tree: Tree, schema: Schema): Promise<{
+    tasks: GeneratorCallback[];
+    projectRoot: string;
+    remoteName: string;
+}>;

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addRemote = void 0;
+const devkit_1 = require("@nx/devkit");
+const project_name_and_root_utils_1 = require("@nx/devkit/src/generators/project-name-and-root-utils");
+const semver_1 = require("semver");
+const check_remote_exists_1 = require("./check-remote-exists");
+const version_utils_1 = require("../../utils/version-utils");
+const remote_1 = require("../../remote/remote");
+const test_runners_1 = require("../../../utils/test-runners");
+async function addRemote(tree, schema) {
+    const tasks = [];
+    const remote = (0, check_remote_exists_1.getRemoteIfExists)(tree, schema.remote);
+    if (!remote) {
+        const installedAngularVersionInfo = (0, version_utils_1.getInstalledAngularVersionInfo)(tree);
+        if ((0, semver_1.lt)(installedAngularVersionInfo.version, '14.1.0') &&
+            schema.standalone) {
+            throw new Error((0, devkit_1.stripIndents) `The "standalone" option is only supported in Angular >= 14.1.0. You are currently using ${installedAngularVersionInfo.version}.
+    You can resolve this error by removing the "standalone" option or by migrating to Angular 14.1.0.`);
+        }
+        const remoteGeneratorCallback = await (0, remote_1.default)(tree, {
+            name: schema.remote,
+            host: schema.host,
+            standalone: schema.standalone,
+            projectNameAndRootFormat: schema.projectNameAndRootFormat ?? 'derived',
+            unitTestRunner: schema.unitTestRunner ?? test_runners_1.UnitTestRunner.Jest,
+            e2eTestRunner: schema.e2eTestRunner ?? test_runners_1.E2eTestRunner.Cypress,
+            skipFormat: true,
+        });
+        tasks.push(remoteGeneratorCallback);
+    }
+    const { projectName, projectRoot: remoteRoot } = await (0, project_name_and_root_utils_1.determineProjectNameAndRootOptions)(tree, {
+        name: schema.remote,
+        projectType: 'application',
+        projectNameAndRootFormat: schema.projectNameAndRootFormat ?? 'derived',
+        callingGenerator: '@nx/angular:federate-module',
+    });
+    const projectRoot = remote ? remote.root : remoteRoot;
+    const remoteName = remote ? remote.name : projectName;
+    // TODO(Colum): add implicit dependency if the path points to a file in a different project
+    return {
+        tasks,
+        projectRoot,
+        remoteName,
+    };
+}
+exports.addRemote = addRemote;

package/src/generators/federate-module/lib/check-remote-exists.d.ts

@@ -0,0 +1,2 @@
+import { type Tree } from '@nx/devkit';
+export declare function getRemoteIfExists(tree: Tree, remote: string): false | import("@nx/devkit").ProjectConfiguration;

package/src/generators/federate-module/lib/check-remote-exists.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRemoteIfExists = void 0;
+const devkit_1 = require("@nx/devkit");
+function getRemoteIfExists(tree, remote) {
+    const remoteProject = getRemote(tree, remote);
+    if (!remoteProject) {
+        return false;
+    }
+    const hasModuleFederationConfig = tree.exists((0, devkit_1.joinPathFragments)(remoteProject.root, 'module-federation.config.ts')) ||
+        tree.exists((0, devkit_1.joinPathFragments)(remoteProject.root, 'module-federation.config.js'));
+    return hasModuleFederationConfig ? remoteProject : false;
+}
+exports.getRemoteIfExists = getRemoteIfExists;
+function getRemote(tree, remote) {
+    try {
+        return (0, devkit_1.readProjectConfiguration)(tree, remote);
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -0,0 +1,4 @@
+export * from './add-remote';
+export * from './add-path-to-ts-config';
+export * from './add-path-to-exposes';
+export * from './add-file-to-remote-tsconfig';

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./add-remote"), exports);
+tslib_1.__exportStar(require("./add-path-to-ts-config"), exports);
+tslib_1.__exportStar(require("./add-path-to-exposes"), exports);
+tslib_1.__exportStar(require("./add-file-to-remote-tsconfig"), exports);

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

@@ -0,0 +1,14 @@
+import { type ProjectNameAndRootFormat } from '@nx/devkit/src/generators/project-name-and-root-utils';
+import { UnitTestRunner, E2eTestRunner } from '../utils/testing';
+
+export interface Schema {
+  name: string;
+  path: string;
+  remote: string;
+  host?: string;
+  projectNameAndRootFormat?: ProjectNameAndRootFormat;
+  unitTestRunner?: UnitTestRunner;
+  e2eTestRunner?: E2eTestRunner;
+  standalone?: boolean;
+  skipFormat?: boolean;
+}

package/src/generators/federate-module/schema.json

@@ -0,0 +1,77 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "cli": "nx",
+  "$id": "NxReactFederateModule",
+  "title": "Federate Module",
+  "description": "Create a federated module, which is exposed by a remote and can be subsequently loaded by a host.",
+  "examples": [
+    {
+      "command": "nx g federate-module MyModule --path=./src/component/my-cmp.ts --remote=my-remote-app",
+      "description": "Create a federated module from my-remote-app, that exposes my-cmp from ./src/component/my-cmp.ts as MyModule."
+    }
+  ],
+  "type": "object",
+  "properties": {
+    "name": {
+      "description": "The name of the module.",
+      "type": "string",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "What name would you like to use for the module?",
+      "pattern": "^[a-zA-Z][^:]*$",
+      "x-priority": "important"
+    },
+    "path": {
+      "type": "string",
+      "description": "The path to locate the federated module.",
+      "x-prompt": "What is the path to the module to be federated?"
+    },
+    "remote": {
+      "type": "string",
+      "description": "The name of the remote.",
+      "x-prompt": "What is/should the remote be named?"
+    },
+    "projectNameAndRootFormat": {
+      "description": "Whether to generate the project name and root directory as provided (`as-provided`) or generate them composing their values and taking the configured layout into account (`derived`).",
+      "type": "string",
+      "enum": ["as-provided", "derived"]
+    },
+    "style": {
+      "description": "The file extension to be used for style files for the remote if one needs to be created.",
+      "type": "string",
+      "default": "css",
+      "enum": ["css", "scss", "sass", "less"]
+    },
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false,
+      "x-priority": "internal"
+    },
+    "unitTestRunner": {
+      "type": "string",
+      "enum": ["jest", "none"],
+      "description": "Test runner to use for unit tests of the remote if it needs to be created.",
+      "default": "jest"
+    },
+    "e2eTestRunner": {
+      "type": "string",
+      "enum": ["cypress", "none"],
+      "description": "Test runner to use for end to end (e2e) tests of the remote if it needs to be created.",
+      "default": "cypress"
+    },
+    "standalone": {
+      "description": "Whether to generate the remote application with standalone components if it needs to be created. _Note: This is only supported in Angular versions >= 14.1.0_",
+      "type": "boolean",
+      "default": false
+    },
+    "host": {
+      "type": "string",
+      "description": "The host / shell application for this remote."
+    }
+  },
+  "required": ["name", "path", "remote"],
+  "additionalProperties": false
+}

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

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

package/src/generators/pipe/files/{__pipeFileName__.pipe.ts__tpl__ → __fileName__.ts__tpl__}

@@ -1,10 +1,10 @@
 import { Pipe, PipeTransform } from '@angular/core';
 
 @Pipe({
-  name: '<%= pipePropertyName %>'<% if(standalone) {%>,
+  name: '<%= selector %>'<% if(standalone) {%>,
   standalone: true<%}%>
 })
-export class <%= pipeClassName %>Pipe implements PipeTransform {
+export class <%= symbolName %> implements PipeTransform {
 
   transform(value: unknown, ...args: unknown[]): unknown {
     return null;

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

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

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

@@ -1,17 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeOptions = void 0;
-const path_1 = require("../../utils/path");
-function normalizeOptions(tree, options) {
-    const { directory, name, path } = (0, path_1.normalizeNameAndPaths)(tree, {
-        ...options,
-        type: 'pipe',
+const artifact_name_and_directory_utils_1 = require("@nx/devkit/src/generators/artifact-name-and-directory-utils");
+const devkit_1 = require("@nx/devkit");
+async function normalizeOptions(tree, options) {
+    const { artifactName: name, directory, fileName, filePath, project, } = await (0, artifact_name_and_directory_utils_1.determineArtifactNameAndDirectoryOptions)(tree, {
+        artifactType: 'pipe',
+        callingGenerator: '@nx/angular:pipe',
+        name: options.name,
+        directory: options.directory ?? options.path,
+        flat: options.flat,
+        nameAndDirectoryFormat: options.nameAndDirectoryFormat,
+        project: options.project,
+        suffix: 'pipe',
     });
+    const { className } = (0, devkit_1.names)(name);
+    const { className: suffixClassName } = (0, devkit_1.names)('pipe');
+    const symbolName = `${className}${suffixClassName}`;
     return {
         ...options,
-        directory,
+        project,
         name,
-        path,
+        directory,
+        fileName,
+        filePath,
+        symbolName,
     };
 }
 exports.normalizeOptions = normalizeOptions;

package/src/generators/pipe/lib/validate-options.js

@@ -3,8 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateOptions = void 0;
 const validations_1 = require("../../utils/validations");
 function validateOptions(tree, options) {
-    (0, validations_1.validateProject)(tree, options.project);
-    (0, validations_1.validatePathIsUnderProjectRoot)(tree, options.project, options.path);
     (0, validations_1.validateStandaloneOption)(tree, options.standalone);
 }
 exports.validateOptions = validateOptions;

package/src/generators/pipe/pipe.js

@@ -6,22 +6,22 @@ const utils_1 = require("../utils");
 const lib_1 = require("./lib");
 async function pipeGenerator(tree, rawOptions) {
     (0, lib_1.validateOptions)(tree, rawOptions);
-    const options = (0, lib_1.normalizeOptions)(tree, rawOptions);
+    const options = await (0, lib_1.normalizeOptions)(tree, rawOptions);
     const pipeNames = (0, devkit_1.names)(options.name);
     (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, 'files'), options.directory, {
-        pipeClassName: pipeNames.className,
-        pipeFileName: pipeNames.fileName,
-        pipePropertyName: pipeNames.propertyName,
+        symbolName: options.symbolName,
+        fileName: options.fileName,
+        selector: pipeNames.propertyName,
         standalone: options.standalone,
         tpl: '',
     });
     if (options.skipTests) {
-        const pathToSpecFile = (0, devkit_1.joinPathFragments)(options.directory, `${pipeNames.fileName}.pipe.spec.ts`);
+        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.path, options.module);
-        (0, utils_1.addToNgModule)(tree, options.path, modulePath, pipeNames.fileName, `${pipeNames.className}Pipe`, `${pipeNames.fileName}.pipe`, 'declarations', options.flat, options.export);
+        const modulePath = (0, utils_1.findModule)(tree, options.directory, options.module);
+        (0, utils_1.addToNgModule)(tree, options.directory, modulePath, '', options.symbolName, options.fileName, 'declarations', options.flat, options.export);
     }
     if (!options.skipFormat) {
         await (0, devkit_1.formatFiles)(tree);

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

@@ -1,17 +1,33 @@
+import { NameAndDirectoryFormat } from '@nx/devkit/src/generators/artifact-name-and-directory-utils';
+
 export interface Schema {
   name: string;
-  project: string;
-  path?: string;
-  flat?: boolean;
+  directory?: string;
+  nameAndDirectoryFormat?: NameAndDirectoryFormat;
   skipTests?: boolean;
   skipImport?: boolean;
   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 v18.
+   */
+  flat?: boolean;
+  /**
+   * @deprecated Provide the `directory` option instead. It will be removed in Nx v18.
+   */
+  path?: string;
+  /**
+   * @deprecated Provide the `directory` option instead. The project will be determined from the directory provided. It will be removed in Nx v18.
+   */
+  project?: string;
 }
 
 export interface NormalizedSchema extends Schema {
   directory: string;
-  path: string;
+  filePath: string;
+  project: string;
+  fileName: string;
+  symbolName: string;
 }

package/src/generators/pipe/schema.json

@@ -5,7 +5,7 @@
   "type": "object",
   "cli": "nx",
   "additionalProperties": false,
-  "description": "Creates a new, generic pipe definition in the given project.",
+  "description": "Creates an Angular pipe.",
   "properties": {
     "name": {
       "type": "string",
@@ -16,14 +16,16 @@
       },
       "x-prompt": "What name would you like to use for the pipe?"
     },
-    "path": {
+    "directory": {
       "type": "string",
-      "format": "path",
-      "$default": {
-        "$source": "workingDirectory"
-      },
-      "description": "The path at which to create the pipe, relative to the workspace root.",
-      "visible": false
+      "description": "The directory at which to create the pipe 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 pipe 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",
@@ -31,12 +33,14 @@
       "$default": {
         "$source": "projectName"
       },
-      "x-dropdown": "projects"
+      "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 v18."
     },
     "flat": {
       "type": "boolean",
       "default": true,
-      "description": "When true (the default) creates files at the top level of the project."
+      "description": "When true (the default) creates files at the top level of the project.",
+      "x-deprecated": "Provide the `directory` option instead and use the `as-provided` format. It will be removed in Nx v18."
     },
     "skipTests": {
       "type": "boolean",
@@ -69,5 +73,5 @@
       "description": "Skip formatting of files."
     }
   },
-  "required": ["name", "project"]
+  "required": ["name"]
 }

package/src/generators/scam/lib/convert-component-to-scam.js

@@ -9,9 +9,6 @@ function convertComponentToScam(tree, options) {
     if (!tree.exists(options.filePath)) {
         throw new Error(`Couldn't find component at path ${options.filePath} to add SCAM setup.`);
     }
-    const componentNames = (0, devkit_1.names)(options.name);
-    const typeNames = (0, devkit_1.names)(options.type ?? 'component');
-    const componentClassName = `${componentNames.className}${typeNames.className}`;
     if (!tsModule) {
         tsModule = (0, ensure_typescript_1.ensureTypescript)();
     }
@@ -21,12 +18,12 @@ function convertComponentToScam(tree, options) {
         source = (0, js_1.insertImport)(tree, source, options.filePath, 'NgModule', '@angular/core');
         source = (0, js_1.insertImport)(tree, source, options.filePath, 'CommonModule', '@angular/common');
         let updatedComponentSource = source.getText();
-        updatedComponentSource = `${updatedComponentSource}${getNgModuleDeclaration(componentClassName)}`;
+        updatedComponentSource = `${updatedComponentSource}${getNgModuleDeclaration(options.symbolName)}`;
         tree.write(options.filePath, updatedComponentSource);
         return;
     }
-    const moduleFilePath = (0, devkit_1.joinPathFragments)(options.directory, `${componentNames.fileName}.module.ts`);
-    tree.write(moduleFilePath, getModuleFileContent(componentClassName, options.fileName));
+    const moduleFilePath = (0, devkit_1.joinPathFragments)(options.directory, `${options.name}.module.ts`);
+    tree.write(moduleFilePath, getModuleFileContent(options.symbolName, options.fileName));
 }
 exports.convertComponentToScam = convertComponentToScam;
 function getModuleFileContent(componentClassName, componentFileName) {

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

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

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

@@ -1,12 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeOptions = void 0;
-const path_1 = require("../../utils/path");
-function normalizeOptions(tree, options) {
-    const { directory, fileName, filePath, name } = (0, path_1.normalizeNameAndPaths)(tree, {
-        ...options,
-        type: options.type ?? 'component',
+const artifact_name_and_directory_utils_1 = require("@nx/devkit/src/generators/artifact-name-and-directory-utils");
+const devkit_1 = require("@nx/devkit");
+async function normalizeOptions(tree, options) {
+    options.type ??= 'component';
+    const { artifactName: name, directory, fileName, filePath, project, } = await (0, artifact_name_and_directory_utils_1.determineArtifactNameAndDirectoryOptions)(tree, {
+        artifactType: options.type,
+        callingGenerator: '@nx/angular:scam',
+        name: options.name,
+        directory: options.directory ?? options.path,
+        flat: options.flat,
+        nameAndDirectoryFormat: options.nameAndDirectoryFormat,
+        project: options.project,
+        suffix: options.type ?? 'component',
     });
+    const { className } = (0, devkit_1.names)(name);
+    const { className: suffixClassName } = (0, devkit_1.names)(options.type);
+    const symbolName = `${className}${suffixClassName}`;
     return {
         ...options,
         export: options.export ?? true,
@@ -15,6 +26,8 @@ function normalizeOptions(tree, options) {
         fileName,
         filePath,
         name,
+        symbolName,
+        project,
     };
 }
 exports.normalizeOptions = normalizeOptions;

package/src/generators/scam/scam.js

@@ -15,7 +15,7 @@ async function scamGenerator(tree, rawOptions) {
         standalone: false,
         skipFormat: true,
     });
-    const options = (0, lib_1.normalizeOptions)(tree, rawOptions);
+    const options = await (0, lib_1.normalizeOptions)(tree, rawOptions);
     (0, lib_1.convertComponentToScam)(tree, options);
     (0, export_scam_1.exportScam)(tree, options);
     if (!options.skipFormat) {

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

@@ -1,7 +1,9 @@
+import { NameAndDirectoryFormat } from '@nx/devkit/src/generators/artifact-name-and-directory-utils';
+
 export interface Schema {
   name: string;
-  project: string;
-  path?: string;
+  directory?: string;
+  nameAndDirectoryFormat?: NameAndDirectoryFormat;
   displayBlock?: boolean;
   inlineStyle?: boolean;
   inlineTemplate?: boolean;
@@ -11,18 +13,31 @@ export interface Schema {
   skipTests?: boolean;
   inlineScam?: boolean;
   type?: string;
-  flat?: boolean;
   prefix?: string;
   selector?: string;
   skipSelector?: boolean;
   export?: boolean;
   skipFormat?: boolean;
+  /**
+   * @deprecated Provide the `directory` option instead and use the `as-provided` format. It will be removed in Nx v18.
+   */
+  flat?: boolean;
+  /**
+   * @deprecated Provide the `directory` option instead. It will be removed in Nx v18.
+   */
+  path?: string;
+  /**
+   * @deprecated Provide the `directory` option instead. The project will be determined from the directory provided. It will be removed in Nx v18.
+   */
+  project?: string;
 }
 
 export interface NormalizedSchema extends Schema {
   directory: string;
+  project: string;
   fileName: string;
   filePath: string;
+  symbolName: string;
   export: boolean;
   inlineScam: boolean;
 }