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

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeOptions = void 0;
+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: projectName, } = await (0, artifact_name_and_directory_utils_1.determineArtifactNameAndDirectoryOptions)(tree, {
+        artifactType: 'pipe',
+        callingGenerator: '@nx/angular:scam-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,
+        export: options.export ?? true,
+        inlineScam: options.inlineScam ?? true,
+        directory,
+        fileName,
+        filePath,
+        name,
+        symbolName,
+        projectName,
+    };
+}
+exports.normalizeOptions = normalizeOptions;

package/src/generators/scam-pipe/scam-pipe.d.ts

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

package/src/generators/scam-pipe/scam-pipe.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scamPipeGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+const pipe_1 = require("../pipe/pipe");
+const export_scam_1 = require("../utils/export-scam");
+const lib_1 = require("./lib");
+async function scamPipeGenerator(tree, rawOptions) {
+    const options = await (0, lib_1.normalizeOptions)(tree, rawOptions);
+    await (0, pipe_1.pipeGenerator)(tree, {
+        ...options,
+        skipImport: true,
+        export: false,
+        standalone: false,
+        skipFormat: true,
+        // options are already normalize, use them as is
+        nameAndDirectoryFormat: 'as-provided',
+    });
+    (0, lib_1.convertPipeToScam)(tree, options);
+    (0, export_scam_1.exportScam)(tree, options);
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+}
+exports.scamPipeGenerator = scamPipeGenerator;
+exports.default = scamPipeGenerator;

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

@@ -0,0 +1,33 @@
+import { NameAndDirectoryFormat } from '@nx/devkit/src/generators/artifact-name-and-directory-utils';
+
+export interface Schema {
+  name: string;
+  directory?: string;
+  nameAndDirectoryFormat?: NameAndDirectoryFormat;
+  skipTests?: boolean;
+  inlineScam?: boolean;
+  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;
+  export: boolean;
+  fileName: string;
+  filePath: string;
+  inlineScam: boolean;
+  projectName: string;
+  symbolName: string;
+}

package/src/generators/scam-pipe/schema.json

@@ -0,0 +1,77 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "SCAMPipeGenerator",
+  "cli": "nx",
+  "title": "SCAM Pipe Generator Options Schema",
+  "type": "object",
+  "examples": [
+    {
+      "command": "nx g @nx/angular:scam-pipe --project=my-lib --flat=false my-transformation",
+      "description": "Generates a `MyTransformationPipe` in a `my-transformation` folder in the `my-lib` project"
+    }
+  ],
+  "description": "Creates a new, generic Angular pipe definition in the given or default project.",
+  "additionalProperties": false,
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "The name of the pipe.",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "What name would you like to use for the pipe?",
+      "x-priority": "important"
+    },
+    "directory": {
+      "type": "string",
+      "description": "The directory at which to create the component 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 component 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."
+    },
+    "skipTests": {
+      "type": "boolean",
+      "description": "Do not create `spec.ts` test files for the new pipe.",
+      "default": false
+    },
+    "inlineScam": {
+      "type": "boolean",
+      "description": "Create the NgModule in the same file as the Pipe.",
+      "default": true,
+      "x-priority": "important"
+    },
+    "flat": {
+      "type": "boolean",
+      "description": "Create 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."
+    },
+    "export": {
+      "type": "boolean",
+      "description": "Specifies if the SCAM should be exported from the project's entry point (normally `index.ts`). It only applies to libraries.",
+      "default": true,
+      "x-priority": "important"
+    },
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false,
+      "x-priority": "internal"
+    }
+  },
+  "required": ["name"]
+}

package/src/generators/scam-to-standalone/lib/convert-scam-to-standalone.d.ts

@@ -0,0 +1,3 @@
+import type { Node, SourceFile } from 'typescript';
+import { Tree } from 'nx/src/generators/tree';
+export declare function convertScamToStandalone(componentAST: SourceFile, componentFileContents: string, importsArray: string[], providersArray: string[], moduleNodes: Array<Node>, tree: Tree, normalizedComponentPath: string, componentName: string): void;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertScamToStandalone = void 0;
+const path_1 = require("path");
+const path_2 = require("nx/src/utils/path");
+function convertScamToStandalone(componentAST, componentFileContents, importsArray, providersArray, moduleNodes, tree, normalizedComponentPath, componentName) {
+    let newComponentContents = '';
+    const COMPONENT_PROPERTY_SELECTOR = 'ClassDeclaration > Decorator > CallExpression:has(Identifier[name=Component]) ObjectLiteralExpression';
+    const { tsquery } = require('@phenomnomnominal/tsquery');
+    const componentDecoratorMetadataNode = tsquery(componentAST, COMPONENT_PROPERTY_SELECTOR, { visitAllChildren: true })[0];
+    newComponentContents = `${componentFileContents.slice(0, componentDecoratorMetadataNode.getStart() - 1)}({
+    standalone: true,
+    imports: [${importsArray.join(',')}],${providersArray.length > 0 ? `providers: [${providersArray.join(',')}],` : ''}${componentFileContents.slice(componentDecoratorMetadataNode.getStart() + 1, moduleNodes[0].getStart() - 1)}`;
+    tree.write(normalizedComponentPath, newComponentContents);
+    const componentPathParts = (0, path_1.parse)(normalizedComponentPath);
+    const pathToComponentSpec = (0, path_2.joinPathFragments)(componentPathParts.dir, '/', `${componentPathParts.name}.spec.ts`);
+    if (tree.exists(pathToComponentSpec)) {
+        const componentSpecContents = tree.read(pathToComponentSpec, 'utf-8');
+        // Only support testbed based tests
+        if (componentSpecContents.includes('TestBed')) {
+            let newComponentSpecContents = componentSpecContents;
+            if (componentSpecContents.includes('imports: [')) {
+                newComponentSpecContents = newComponentSpecContents.replace('imports: [', `imports: [${componentName}, `);
+                newComponentSpecContents.replace(/declarations: \[.+/, '');
+            }
+            else {
+                newComponentSpecContents = newComponentSpecContents.replace('declarations: [', 'imports: [');
+            }
+            tree.write(pathToComponentSpec, newComponentSpecContents);
+        }
+    }
+}
+exports.convertScamToStandalone = convertScamToStandalone;

package/src/generators/scam-to-standalone/lib/get-component-data-from-ast.d.ts

@@ -0,0 +1,6 @@
+import type { Tree } from 'nx/src/generators/tree';
+export declare function getComponentDataFromAST(tree: Tree, normalizedComponentPath: string): {
+    componentFileContents: string;
+    componentAST: any;
+    componentName: any;
+};

package/src/generators/scam-to-standalone/lib/get-component-data-from-ast.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getComponentDataFromAST = void 0;
+function getComponentDataFromAST(tree, normalizedComponentPath) {
+    const COMPONENT_CONTENT_SELECTOR = 'ClassDeclaration:has(Decorator > CallExpression:has(Identifier[name=Component]))';
+    const COMPONENT_NAME_SELECTOR = 'ClassDeclaration:has(Decorator > CallExpression:has(Identifier[name=Component])) > Identifier';
+    const componentFileContents = tree.read(normalizedComponentPath, 'utf-8');
+    const { tsquery } = require('@phenomnomnominal/tsquery');
+    const componentAST = tsquery.ast(componentFileContents);
+    const componentNode = tsquery(componentAST, COMPONENT_CONTENT_SELECTOR, {
+        visitAllChildren: true,
+    })[0];
+    const componentContents = componentFileContents.slice(componentNode.getStart(), componentNode.getEnd());
+    const componentNameNode = tsquery(tsquery.ast(componentContents), COMPONENT_NAME_SELECTOR, { visitAllChildren: true })[0];
+    const componentName = componentNameNode.getText();
+    return { componentFileContents, componentAST, componentName };
+}
+exports.getComponentDataFromAST = getComponentDataFromAST;

package/src/generators/scam-to-standalone/lib/get-module-metadata-from-ast.d.ts

@@ -0,0 +1,9 @@
+import type { SourceFile } from 'typescript';
+export declare function getModuleMetadataFromAST(componentAST: SourceFile, componentFileContents: string): {
+    moduleNodes: any;
+    exportsArray: string[];
+    importsArray: string[];
+    declarationsArray: string[];
+    providersArray: string[];
+    moduleName: any;
+};

package/src/generators/scam-to-standalone/lib/get-module-metadata-from-ast.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModuleMetadataFromAST = void 0;
+function getModuleMetadataFromAST(componentAST, componentFileContents) {
+    const NGMODULE_CONTENT_SELECTOR = 'ClassDeclaration:has(Decorator > CallExpression:has(Identifier[name=NgModule]))';
+    const { tsquery } = require('@phenomnomnominal/tsquery');
+    const moduleNodes = tsquery(componentAST, NGMODULE_CONTENT_SELECTOR, {
+        visitAllChildren: true,
+    });
+    const moduleContents = componentFileContents.slice(moduleNodes[0].getStart(), moduleNodes[0].getEnd());
+    // verify module is a scam
+    const NGMODULE_EXPORTS_SELECTOR = 'ClassDeclaration > Decorator > CallExpression:has(Identifier[name=NgModule]) ObjectLiteralExpression > PropertyAssignment:has(Identifier[name=exports]) ArrayLiteralExpression';
+    const NGMODULE_DECLARATIONS_SELECTOR = 'ClassDeclaration > Decorator > CallExpression:has(Identifier[name=NgModule]) ObjectLiteralExpression > PropertyAssignment:has(Identifier[name=declarations]) ArrayLiteralExpression';
+    const NGMODULE_IMPORTS_SELECTOR = 'ClassDeclaration > Decorator > CallExpression:has(Identifier[name=NgModule]) ObjectLiteralExpression > PropertyAssignment:has(Identifier[name=imports]) ArrayLiteralExpression';
+    const NGMODULE_PROVIDERS_SELECTOR = 'ClassDeclaration > Decorator > CallExpression:has(Identifier[name=NgModule]) ObjectLiteralExpression > PropertyAssignment:has(Identifier[name=providers]) ArrayLiteralExpression';
+    const NGMODULE_NAME_SELECTOR = 'ClassDeclaration:has(Decorator > CallExpression:has(Identifier[name=NgModule])) > Identifier';
+    const moduleAST = tsquery.ast(moduleContents);
+    const importsNode = tsquery(moduleAST, NGMODULE_IMPORTS_SELECTOR, {
+        visitAllChildren: true,
+    })[0];
+    const exportsNode = tsquery(moduleAST, NGMODULE_EXPORTS_SELECTOR, {
+        visitAllChildren: true,
+    })[0];
+    const declarationsNode = tsquery(moduleAST, NGMODULE_DECLARATIONS_SELECTOR, {
+        visitAllChildren: true,
+    })[0];
+    const providersNodes = tsquery(moduleAST, NGMODULE_PROVIDERS_SELECTOR, {
+        visitAllChildren: true,
+    });
+    const exportsArray = moduleContents
+        .slice(exportsNode.getStart(), exportsNode.getEnd())
+        .replace('[', '')
+        .replace(']', '')
+        .split(',');
+    const importsArray = moduleContents
+        .slice(importsNode.getStart(), importsNode.getEnd())
+        .replace('[', '')
+        .replace(']', '')
+        .split(',');
+    const declarationsArray = moduleContents
+        .slice(declarationsNode.getStart(), declarationsNode.getEnd())
+        .replace('[', '')
+        .replace(']', '')
+        .split(',');
+    const providersArray = providersNodes.length > 0
+        ? moduleContents
+            .slice(providersNodes[0].getStart(), providersNodes[0].getEnd())
+            .replace('[', '')
+            .replace(']', '')
+            .split(',')
+        : [];
+    const moduleName = tsquery(moduleAST, NGMODULE_NAME_SELECTOR, {
+        visitAllChildren: true,
+    })[0].getText();
+    return {
+        moduleNodes,
+        exportsArray,
+        importsArray,
+        declarationsArray,
+        providersArray,
+        moduleName,
+    };
+}
+exports.getModuleMetadataFromAST = getModuleMetadataFromAST;

package/src/generators/scam-to-standalone/lib/get-target-project.d.ts

@@ -0,0 +1,2 @@
+import { ProjectConfiguration } from 'nx/src/config/workspace-json-project-json';
+export declare function getTargetProject(projectName: string, projects: Map<string, ProjectConfiguration>): ProjectConfiguration;

package/src/generators/scam-to-standalone/lib/get-target-project.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTargetProject = void 0;
+function getTargetProject(projectName, projects) {
+    let project;
+    if (projectName && !projects.has(projectName)) {
+        throw new Error(`Project (${projectName}) does not exist in the workspace! Please provide a valid project name.`);
+    }
+    else if (projectName && projects.has(projectName)) {
+        project = projects.get(projectName);
+    }
+    return project;
+}
+exports.getTargetProject = getTargetProject;

package/src/generators/scam-to-standalone/lib/index.d.ts

@@ -0,0 +1,8 @@
+export * from './convert-scam-to-standalone';
+export * from './get-component-data-from-ast';
+export * from './get-module-metadata-from-ast';
+export * from './get-target-project';
+export * from './replace-module-usages-with-component';
+export * from './selector-exists-in-ast';
+export * from './verify-is-inline-scam';
+export * from './verify-module-is-scam';

package/src/generators/scam-to-standalone/lib/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./convert-scam-to-standalone"), exports);
+tslib_1.__exportStar(require("./get-component-data-from-ast"), exports);
+tslib_1.__exportStar(require("./get-module-metadata-from-ast"), exports);
+tslib_1.__exportStar(require("./get-target-project"), exports);
+tslib_1.__exportStar(require("./replace-module-usages-with-component"), exports);
+tslib_1.__exportStar(require("./selector-exists-in-ast"), exports);
+tslib_1.__exportStar(require("./verify-is-inline-scam"), exports);
+tslib_1.__exportStar(require("./verify-module-is-scam"), exports);

package/src/generators/scam-to-standalone/lib/replace-module-usages-with-component.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from 'nx/src/generators/tree';
+export declare function replaceModuleUsagesWithComponent(tree: Tree, moduleName: string, componentName: string): void;

package/src/generators/scam-to-standalone/lib/replace-module-usages-with-component.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceModuleUsagesWithComponent = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+function replaceModuleUsagesWithComponent(tree, moduleName, componentName) {
+    (0, devkit_1.visitNotIgnoredFiles)(tree, '/', (path) => {
+        if ((0, path_1.extname)(path) !== '.ts') {
+            return;
+        }
+        const fileContents = tree.read(path, 'utf-8');
+        if (fileContents.includes(moduleName)) {
+            const moduleNameRegex = new RegExp(moduleName, 'g');
+            const newFileContents = fileContents.replace(moduleNameRegex, componentName);
+            tree.write(path, newFileContents);
+        }
+    });
+}
+exports.replaceModuleUsagesWithComponent = replaceModuleUsagesWithComponent;

package/src/generators/scam-to-standalone/lib/selector-exists-in-ast.d.ts

@@ -0,0 +1,2 @@
+import type { SourceFile } from 'typescript';
+export declare function selectorExistsInAST(selector: string, ast: SourceFile): boolean;

package/src/generators/scam-to-standalone/lib/selector-exists-in-ast.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectorExistsInAST = void 0;
+function selectorExistsInAST(selector, ast) {
+    const { tsquery } = require('@phenomnomnominal/tsquery');
+    return tsquery(ast, selector, { visitAllChildren: true }).length > 0;
+}
+exports.selectorExistsInAST = selectorExistsInAST;

package/src/generators/scam-to-standalone/lib/verify-is-inline-scam.d.ts

@@ -0,0 +1,2 @@
+import type { SourceFile } from 'typescript';
+export declare function verifyIsInlineScam(componentAST: SourceFile): boolean;

package/src/generators/scam-to-standalone/lib/verify-is-inline-scam.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyIsInlineScam = void 0;
+const selector_exists_in_ast_1 = require("./selector-exists-in-ast");
+function verifyIsInlineScam(componentAST) {
+    const NGMODULE_DECORATOR_SELECTOR = 'ClassDeclaration > Decorator > CallExpression:has(Identifier[name=NgModule])';
+    const COMPONENT_DECORATOR_SELECTOR = 'ClassDeclaration > Decorator > CallExpression:has(Identifier[name=Component])';
+    return ((0, selector_exists_in_ast_1.selectorExistsInAST)(COMPONENT_DECORATOR_SELECTOR, componentAST) &&
+        (0, selector_exists_in_ast_1.selectorExistsInAST)(NGMODULE_DECORATOR_SELECTOR, componentAST));
+}
+exports.verifyIsInlineScam = verifyIsInlineScam;

package/src/generators/scam-to-standalone/lib/verify-module-is-scam.d.ts

@@ -0,0 +1 @@
+export declare function verifyModuleIsScam(exportsArray: string[], componentName: string, declarationsArray: string[]): void;

package/src/generators/scam-to-standalone/lib/verify-module-is-scam.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyModuleIsScam = void 0;
+function verifyModuleIsScam(exportsArray, componentName, declarationsArray) {
+    // Check exports has 1 export and check export exists in declaration and is the same as the component name
+    if (exportsArray.length !== 1 &&
+        !(exportsArray.includes(componentName) &&
+            declarationsArray.includes(componentName))) {
+        throw new Error(`The NgModule is not a SCAM. Please ensure the NgModule only contains one export and that the component is both declared and exported from the NgModule.`);
+    }
+}
+exports.verifyModuleIsScam = verifyModuleIsScam;

package/src/generators/scam-to-standalone/scam-to-standalone.d.ts

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

package/src/generators/scam-to-standalone/scam-to-standalone.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scamToStandalone = void 0;
+const devkit_1 = require("@nx/devkit");
+const lib_1 = require("./lib");
+async function scamToStandalone(tree, { component, project: projectName, skipFormat }) {
+    const projects = (0, devkit_1.getProjects)(tree);
+    let project = (0, lib_1.getTargetProject)(projectName, projects);
+    const normalizedComponentPath = (0, devkit_1.joinPathFragments)(project.root, component);
+    if (!tree.exists(normalizedComponentPath)) {
+        throw new Error(`The path provided to the component (${normalizedComponentPath}) does not exist. Please ensure the correct path has been provided.`);
+    }
+    const { componentFileContents, componentAST, componentName } = (0, lib_1.getComponentDataFromAST)(tree, normalizedComponentPath);
+    const isInlineScam = (0, lib_1.verifyIsInlineScam)(componentAST);
+    if (!isInlineScam) {
+        throw new Error('This generator currently only supports inline SCAMs. We could not find an accompanying NgModule within the component file, please ensure the SCAM provided is an inline scam.');
+    }
+    const { moduleNodes, exportsArray, importsArray, declarationsArray, providersArray, moduleName, } = (0, lib_1.getModuleMetadataFromAST)(componentAST, componentFileContents);
+    (0, lib_1.verifyModuleIsScam)(exportsArray, componentName, declarationsArray);
+    (0, lib_1.convertScamToStandalone)(componentAST, componentFileContents, importsArray, providersArray, moduleNodes, tree, normalizedComponentPath, componentName);
+    (0, lib_1.replaceModuleUsagesWithComponent)(tree, moduleName, componentName);
+    if (!skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+}
+exports.scamToStandalone = scamToStandalone;
+exports.default = scamToStandalone;

package/src/generators/scam-to-standalone/schema.d.ts

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

package/src/generators/scam-to-standalone/schema.json

@@ -0,0 +1,32 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "GeneratorAngularScamToStandalone",
+  "cli": "nx",
+  "title": "Convert an Inline SCAM to Standalone Component",
+  "description": "Convert an Inline SCAM to a Standalone Component.",
+  "type": "object",
+  "properties": {
+    "component": {
+      "type": "string",
+      "description": "The path to the SCAM component file, relative to the root of the project containing the SCAM.",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-priority": "important"
+    },
+    "project": {
+      "type": "string",
+      "description": "The project containing the SCAM.",
+      "x-prompt": "What project contains the SCAM?",
+      "x-dropdown": "projects",
+      "x-priority": "important"
+    },
+    "skipFormat": {
+      "type": "boolean",
+      "description": "Skip formatting the workspace after the generator completes.",
+      "x-priority": "internal"
+    }
+  },
+  "examplesFile": "../../../docs/scam-to-standalone-examples.md"
+}

package/src/generators/setup-mf/files/entry-module-files/entry.component.ts__tmpl__

@@ -0,0 +1,9 @@
+import { Component } from '@angular/core';
+
+@Component({<% if (prefix) { %>
+  selector: '<%= prefix %>-<%= appName %>-entry',
+  template: `<<%= prefix %>-nx-welcome></<%= prefix %>-nx-welcome>`<% } else { %>
+  selector: '<%= appName %>-entry',
+  template: `<nx-welcome></nx-welcome>`<% } %>
+})
+export class RemoteEntryComponent {}

package/src/generators/setup-mf/files/entry-module-files/entry.module.ts__tmpl__

@@ -0,0 +1,18 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';<% if(routing) { %>
+import { RouterModule } from '@angular/router';<% } %>
+
+import { RemoteEntryComponent } from './entry.component';
+import { NxWelcomeComponent } from './nx-welcome.component';<% if(routing) { %>
+import { remoteRoutes } from './entry.routes';<% } %>
+
+@NgModule({
+  declarations: [RemoteEntryComponent, NxWelcomeComponent],
+  imports: [
+    CommonModule,<% if(routing) { %>
+    RouterModule.forChild(remoteRoutes),<% } %>
+  ],
+  providers: [],<% if(!routing) { %>
+  exports: [RemoteEntryComponent],<% } %>
+})
+export class RemoteEntryModule {}

package/src/generators/setup-mf/files/entry-module-files/entry.routes.ts__tmpl__

@@ -0,0 +1,4 @@
+import { Route } from '@angular/router';
+import { RemoteEntryComponent } from './entry.component';
+
+export const remoteRoutes: Route[] = [{ path: '', component: RemoteEntryComponent }];

package/src/generators/setup-mf/files/host-files/app.component.spec.ts__tmpl__

@@ -0,0 +1,44 @@
+import { fakeAsync, TestBed, tick } from '@angular/core/testing';
+import { AppComponent } from './app.component';
+import { NxWelcomeComponent } from './nx-welcome.component';
+import { RouterTestingModule } from '@angular/router/testing';
+import { Router } from '@angular/router';
+
+describe('AppComponent', () => {
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      imports: [
+        RouterTestingModule.withRoutes([
+          { path: '', component: NxWelcomeComponent },
+        ]),<% if (standalone) { %>
+        AppComponent,
+        NxWelcomeComponent,<% } %>
+      ],<% if (!standalone) { %>
+      declarations: [AppComponent, NxWelcomeComponent],<% } %>
+    }).compileComponents();
+  });
+
+  it('should create the app', () => {
+    const fixture = TestBed.createComponent(AppComponent);
+    const app = fixture.componentInstance;
+    expect(app).toBeTruthy();
+  });
+
+  it(`should have as title '<%= appName %>'`, () => {
+    const fixture = TestBed.createComponent(AppComponent);
+    const app = fixture.componentInstance;
+    expect(app.title).toEqual('<%= appName %>');
+  });
+
+  it('should render title', fakeAsync(() => {
+    const fixture = TestBed.createComponent(AppComponent);
+    const router = TestBed.inject(Router);
+    fixture.ngZone?.run(() => router.navigate(['']));
+    tick();
+    fixture.detectChanges();
+    const compiled = fixture.nativeElement as HTMLElement;
+    expect(compiled.querySelector('h1')?.textContent).toContain(
+      'Welcome <%= appName %>'
+    );
+  }));
+});

package/src/generators/setup-mf/files/standalone-entry-component-files/entry.component.ts__tmpl__

@@ -0,0 +1,13 @@
+import { Component } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { NxWelcomeComponent } from './nx-welcome.component';
+
+@Component({
+  standalone: true,
+  imports: [CommonModule, NxWelcomeComponent],<% if (prefix) { %>
+  selector: '<%= prefix %>-<%= appName %>-entry',
+  template: `<<%= prefix %>-nx-welcome></<%= prefix %>-nx-welcome>`<% } else { %>
+  selector: '<%= appName %>-entry',
+  template: `<nx-welcome></nx-welcome>`<% } %>
+})
+export class RemoteEntryComponent {}

package/src/generators/setup-mf/files/standalone-entry-component-files/entry.routes.ts__tmpl__

@@ -0,0 +1,4 @@
+import { Route } from '@angular/router';
+import { RemoteEntryComponent } from './entry.component';
+
+export const remoteRoutes: Route[] = [{ path: '', component: RemoteEntryComponent }];

package/src/generators/setup-mf/files/ts-webpack/module-federation.config.ts__tmpl__

@@ -0,0 +1,24 @@
+import { ModuleFederationConfig } from '@nx/webpack';
+
+const config: ModuleFederationConfig = {
+  name: '<%= name %>',<% if(type === 'host') { %>
+  /**
+   * To use a remote that does not exist in your current Nx Workspace
+   * You can use the tuple-syntax to define your remote
+   *
+   * remotes: [['my-external-remote', 'https://nx-angular-remote.netlify.app']]
+   *
+   * You _may_ need to add a `remotes.d.ts` file to your `src/` folder declaring the external remote for tsc, with the
+   * following content:
+   *
+   * declare module 'my-external-remote';
+   *
+   */
+  remotes: [<% remotes.forEach(function(remote) { %>'<%= remote.remoteName %>',<% }); %>]<% } %><% if(type === 'remote') { %>
+  exposes: {<% if(standalone) { %>
+    './Routes': '<%= projectRoot %>/src/app/remote-entry/entry.routes.ts',<% } else { %>
+    './Module': '<%= projectRoot %>/src/app/remote-entry/entry.module.ts',<% } %>
+  },<% } %>
+};
+
+export default config;