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

package/src/generators/pipe/schema.json

@@ -0,0 +1,77 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "SchematicsAngularPipe",
+  "title": "Angular Pipe Options Schema",
+  "type": "object",
+  "cli": "nx",
+  "additionalProperties": false,
+  "description": "Creates an Angular pipe.",
+  "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?"
+    },
+    "directory": {
+      "type": "string",
+      "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",
+      "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."
+    },
+    "flat": {
+      "type": "boolean",
+      "default": true,
+      "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 v19."
+    },
+    "skipTests": {
+      "type": "boolean",
+      "description": "Do not create \"spec.ts\" test files for the new pipe.",
+      "default": false
+    },
+    "skipImport": {
+      "type": "boolean",
+      "default": false,
+      "description": "Do not import this pipe into the owning NgModule."
+    },
+    "standalone": {
+      "description": "Whether the generated pipe is standalone.",
+      "type": "boolean",
+      "default": true
+    },
+    "module": {
+      "type": "string",
+      "description": "The filename of the declaring NgModule.",
+      "alias": "m"
+    },
+    "export": {
+      "type": "boolean",
+      "default": false,
+      "description": "The declaring NgModule exports this pipe."
+    },
+    "skipFormat": {
+      "type": "boolean",
+      "default": false,
+      "description": "Skip formatting of files."
+    }
+  },
+  "required": ["name"]
+}

package/src/generators/remote/files/base/webpack.server.config.js__tmpl__

@@ -0,0 +1,3 @@
+const { withModuleFederationForSSR } = require('@nx/angular/module-federation');
+const config = require('./module-federation.config');
+module.exports = withModuleFederationForSSR(config)

package/src/generators/remote/files/base-ts/webpack.server.config.ts__tmpl__

@@ -0,0 +1,4 @@
+import { withModuleFederationForSSR } from '@nx/angular/module-federation';
+import config from './module-federation.config';
+
+export default withModuleFederationForSSR(config);

package/src/generators/remote/files/common/pre-v17/src/main.server.ts__tmpl__

@@ -0,0 +1,72 @@
+import 'zone.js/dist/zone-node';
+
+import { APP_BASE_HREF } from '@angular/common';
+import { ngExpressEngine } from '@nguniversal/express-engine';
+import * as express from 'express';
+import * as cors from 'cors';
+import { existsSync } from 'fs';
+import { join } from 'path';
+
+import<% if(standalone) { %> bootstrap <% } else { %> { AppServerModule } <% } %>from './bootstrap.server';
+
+// The Express app is exported so that it can be used by serverless Functions.
+export function app(): express.Express {
+  const server = express();
+  const browserBundles = join(process.cwd(), '<%= browserBundleOutput %>');
+  const serverBundles = join(process.cwd(), '<%= serverBundleOutput %>');
+
+  server.use(cors());
+  const indexHtml = existsSync(join(browserBundles, 'index.original.html'))
+    ? 'index.original.html'
+    : 'index';
+
+  // Our Universal express-engine (found @ https://github.com/angular/universal/tree/main/modules/express-engine)
+  server.engine(
+    'html',
+    ngExpressEngine({
+      <% if(standalone) { %>bootstrap<% } else { %>bootstrap: AppServerModule,<% } %>
+    })
+  );
+
+  server.set('view engine', 'html');
+  server.set('views', browserBundles);
+
+  // Example Express Rest API endpoints
+  // server.get('/api/**', (req, res) => { });
+  // Serve static files from /browser
+  // serve static files
+  server.get('*.*', express.static(browserBundles, { maxAge: '1y' }));
+  server.use('/server', express.static(serverBundles, { maxAge: '1y' }));
+
+  // All regular routes use the Universal engine
+  server.get('*', (req, res) => {
+    res.render(indexHtml, {
+      req,
+      providers: [{ provide: APP_BASE_HREF, useValue: req.baseUrl }],
+    });
+  });
+
+  return server;
+}
+
+function run(): void {
+  const port = process.env['PORT'] || 4000;
+
+  // Start up the Node server
+  const server = app();
+  server.listen(port, () => {
+    console.log(`Node Express server listening on http://localhost:${port}`);
+
+    /**
+     * DO NOT REMOVE IF USING @nx/angular:module-federation-dev-ssr executor
+     * to serve your Host application with this Remote application.
+     * This message allows Nx to determine when the Remote is ready to be
+     * consumed by the Host.
+     */
+    process.send && process.send('nx.server.ready');
+  });
+}
+
+run();
+
+<% if(standalone) { %>export default bootstrap;<% } else { %>export * from './bootstrap.server';<% } %>

package/src/generators/remote/files/common/v17+/src/main.server.ts__tmpl__

@@ -0,0 +1,73 @@
+import 'zone.js/node';
+
+import { APP_BASE_HREF } from '@angular/common';
+import { CommonEngine } from '@angular/ssr';
+import * as express from 'express';
+import * as cors from 'cors';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import<% if(standalone) { %> bootstrap <% } else { %> { AppServerModule } <% } %>from './bootstrap.server';
+
+// The Express app is exported so that it can be used by serverless Functions.
+export function app(): express.Express {
+  const server = express();
+  const browserBundles = join(process.cwd(), '<%= browserBundleOutput %>');
+  const serverBundles = join(process.cwd(), '<%= serverBundleOutput %>');
+  const indexHtml = existsSync(join(browserBundles, 'index.original.html'))
+    ? join(browserBundles, 'index.original.html')
+    : join(browserBundles, 'index.html');
+
+  server.use(cors());
+
+  const commonEngine = new CommonEngine();
+
+  server.set('view engine', 'html');
+  server.set('views', browserBundles);
+
+  // Example Express Rest API endpoints
+  // server.get('/api/**', (req, res) => { });
+  // Serve static files from /browser
+  server.get('*.*', express.static(browserBundles, { maxAge: '1y' }));
+  // Serve static files from /server
+  server.use('/server', express.static(serverBundles, { maxAge: '1y' }));
+
+  // All regular routes use the Angular engine
+  server.get('*', (req, res, next) => {
+    const { protocol, originalUrl, baseUrl, headers } = req;
+
+    commonEngine
+      .render({
+        bootstrap<% if (!standalone) { %>: AppServerModule<% } %>,
+        documentFilePath: indexHtml,
+        url: `${protocol}://${headers.host}${originalUrl}`,
+        publicPath: browserBundles,
+        providers: [{ provide: APP_BASE_HREF, useValue: baseUrl }],
+      })
+      .then((html) => res.send(html))
+      .catch((err) => next(err));
+  });
+
+  return server;
+}
+
+function run(): void {
+  const port = process.env['PORT'] || 4000;
+
+  // Start up the Node server
+  const server = app();
+  server.listen(port, () => {
+    console.log(`Node Express server listening on http://localhost:${port}`);
+
+    /**
+     * DO NOT REMOVE IF USING @nx/angular:module-federation-dev-ssr executor
+     * to serve your Host application with this Remote application.
+     * This message allows Nx to determine when the Remote is ready to be
+     * consumed by the Host.
+     */
+    process.send && process.send('nx.server.ready');
+  });
+}
+
+run();
+
+export default <% if (standalone) { %>bootstrap<% } else { %>AppServerModule<% } %>;

package/src/generators/remote/files/standalone/src/bootstrap.server.ts__tmpl__

@@ -0,0 +1,7 @@
+import {bootstrapApplication} from '@angular/platform-browser';
+import {RemoteEntryComponent} from './app/remote-entry/entry.component';
+import {config} from './app/app.config.server';
+
+const bootstrap = () => bootstrapApplication(RemoteEntryComponent, config);
+
+export default bootstrap;

package/src/generators/remote/lib/find-next-available-port.d.ts

@@ -0,0 +1,2 @@
+import type { Tree } from '@nx/devkit';
+export declare function findNextAvailablePort(tree: Tree): number;

package/src/generators/remote/lib/find-next-available-port.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findNextAvailablePort = void 0;
+const devkit_1 = require("@nx/devkit");
+const get_mf_projects_1 = require("../../../utils/get-mf-projects");
+function findNextAvailablePort(tree) {
+    const mfProjects = (0, get_mf_projects_1.getMFProjects)(tree);
+    const ports = new Set([4200]);
+    for (const mfProject of mfProjects) {
+        const { targets } = (0, devkit_1.readProjectConfiguration)(tree, mfProject);
+        const port = targets?.serve?.options?.port ?? 4200;
+        ports.add(port);
+    }
+    const nextAvailablePort = Math.max(...ports) + 1;
+    return nextAvailablePort;
+}
+exports.findNextAvailablePort = findNextAvailablePort;

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

@@ -0,0 +1,2 @@
+export * from './find-next-available-port';
+export * from './update-ssr-setup';

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./find-next-available-port"), exports);
+tslib_1.__exportStar(require("./update-ssr-setup"), exports);

package/src/generators/remote/lib/update-ssr-setup.d.ts

@@ -0,0 +1,7 @@
+import type { Tree } from '@nx/devkit';
+export declare function updateSsrSetup(tree: Tree, { appName, port, standalone, typescriptConfiguration, }: {
+    appName: string;
+    port: number;
+    standalone: boolean;
+    typescriptConfiguration: boolean;
+}): Promise<import("@nx/devkit").GeneratorCallback>;

package/src/generators/remote/lib/update-ssr-setup.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateSsrSetup = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const versions_1 = require("../../../utils/versions");
+const version_utils_1 = require("../../utils/version-utils");
+async function updateSsrSetup(tree, { appName, port, standalone, typescriptConfiguration, }) {
+    let project = (0, devkit_1.readProjectConfiguration)(tree, appName);
+    tree.rename((0, devkit_1.joinPathFragments)(project.sourceRoot, 'main.server.ts'), (0, devkit_1.joinPathFragments)(project.sourceRoot, 'bootstrap.server.ts'));
+    tree.write((0, devkit_1.joinPathFragments)(project.root, 'server.ts'), "import('./src/main.server');");
+    const browserBundleOutput = project.targets.build.options.outputPath;
+    const serverBundleOutput = project.targets.build.options.outputPath.replace(/\/browser$/, '/server');
+    const { major: angularMajorVersion } = (0, version_utils_1.getInstalledAngularVersionInfo)(tree);
+    (0, devkit_1.generateFiles)(tree, (0, path_1.join)(__dirname, '../files/common', angularMajorVersion >= 17 ? 'v17+' : 'pre-v17'), project.root, {
+        appName,
+        browserBundleOutput,
+        serverBundleOutput,
+        standalone,
+        tmpl: '',
+    });
+    const pathToTemplateFiles = typescriptConfiguration ? 'base-ts' : 'base';
+    (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, `../files/${pathToTemplateFiles}`), project.root, {
+        tmpl: '',
+    });
+    if (standalone) {
+        (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, '../files/standalone'), project.root, {
+            appName,
+            standalone,
+            tmpl: '',
+        });
+    }
+    // update project.json
+    project = (0, devkit_1.readProjectConfiguration)(tree, appName);
+    project.targets.server.executor = '@nx/angular:webpack-server';
+    project.targets.server.options.customWebpackConfig = {
+        path: (0, devkit_1.joinPathFragments)(project.root, `webpack.server.config.${typescriptConfiguration ? 'ts' : 'js'}`),
+    };
+    project.targets['serve-ssr'].options = {
+        ...(project.targets['serve-ssr'].options ?? {}),
+        port,
+    };
+    project.targets['static-server'] = {
+        dependsOn: ['build', 'server'],
+        executor: 'nx:run-commands',
+        options: {
+            command: `PORT=${port} node ${(0, devkit_1.joinPathFragments)(project.targets.server.options.outputPath, 'main.js')}`,
+        },
+    };
+    (0, devkit_1.updateProjectConfiguration)(tree, appName, project);
+    const installTask = (0, devkit_1.addDependenciesToPackageJson)(tree, {
+        cors: versions_1.corsVersion,
+        '@module-federation/node': versions_1.moduleFederationNodeVersion,
+    }, {
+        '@types/cors': versions_1.typesCorsVersion,
+    });
+    return installTask;
+}
+exports.updateSsrSetup = updateSsrSetup;

package/src/generators/remote/remote.d.ts

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

package/src/generators/remote/remote.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remoteInternal = exports.remote = 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 test_runners_1 = require("../../utils/test-runners");
+const application_1 = require("../application/application");
+const setup_mf_1 = require("../setup-mf/setup-mf");
+const lib_1 = require("./lib");
+const versions_1 = require("@nx/js/src/utils/versions");
+const add_mf_env_to_inputs_1 = require("../utils/add-mf-env-to-inputs");
+async function remote(tree, options) {
+    return await remoteInternal(tree, {
+        projectNameAndRootFormat: 'derived',
+        ...options,
+    });
+}
+exports.remote = remote;
+async function remoteInternal(tree, schema) {
+    const { typescriptConfiguration = true, ...options } = schema;
+    options.standalone = options.standalone ?? true;
+    const projects = (0, devkit_1.getProjects)(tree);
+    if (options.host && !projects.has(options.host)) {
+        throw new Error(`The name of the application to be used as the host app does not exist. (${options.host})`);
+    }
+    const { projectName: remoteProjectName, projectNameAndRootFormat } = await (0, project_name_and_root_utils_1.determineProjectNameAndRootOptions)(tree, {
+        name: options.name,
+        projectType: 'application',
+        directory: options.directory,
+        projectNameAndRootFormat: options.projectNameAndRootFormat,
+        callingGenerator: '@nx/angular:remote',
+    });
+    options.projectNameAndRootFormat = projectNameAndRootFormat;
+    const port = options.port ?? (0, lib_1.findNextAvailablePort)(tree);
+    const appInstallTask = await (0, application_1.applicationGenerator)(tree, {
+        ...options,
+        standalone: options.standalone,
+        routing: true,
+        port,
+        skipFormat: true,
+        bundler: 'webpack',
+    });
+    const skipE2E = !options.e2eTestRunner || options.e2eTestRunner === test_runners_1.E2eTestRunner.None;
+    await (0, setup_mf_1.setupMf)(tree, {
+        appName: remoteProjectName,
+        mfType: 'remote',
+        routing: true,
+        host: options.host,
+        port,
+        skipPackageJson: options.skipPackageJson,
+        skipFormat: true,
+        skipE2E,
+        e2eProjectName: skipE2E ? undefined : `${remoteProjectName}-e2e`,
+        standalone: options.standalone,
+        prefix: options.prefix,
+        typescriptConfiguration,
+        setParserOptionsProject: options.setParserOptionsProject,
+    });
+    const installSwcHelpersTask = (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+        '@swc/helpers': versions_1.swcHelpersVersion,
+    });
+    let installTasks = [appInstallTask, installSwcHelpersTask];
+    if (options.ssr) {
+        let ssrInstallTask = await (0, lib_1.updateSsrSetup)(tree, {
+            appName: remoteProjectName,
+            port,
+            typescriptConfiguration,
+            standalone: options.standalone,
+        });
+        installTasks.push(ssrInstallTask);
+    }
+    (0, add_mf_env_to_inputs_1.addMfEnvToTargetDefaultInputs)(tree);
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return (0, devkit_1.runTasksInSerial)(...installTasks);
+}
+exports.remoteInternal = remoteInternal;
+exports.default = remote;

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

@@ -0,0 +1,32 @@
+import type { ProjectNameAndRootFormat } from '@nx/devkit/src/generators/project-name-and-root-utils';
+import type { Linter } from '@nx/eslint';
+import type { E2eTestRunner, UnitTestRunner } from '../../utils/test-runners';
+import type { Styles } from '../utils/types';
+
+export interface Schema {
+  name: string;
+  host?: string;
+  port?: number;
+  setParserOptionsProject?: boolean;
+  skipPackageJson?: boolean;
+  addTailwind?: boolean;
+  prefix?: string;
+  style?: Styles;
+  skipTests?: boolean;
+  directory?: string;
+  projectNameAndRootFormat?: ProjectNameAndRootFormat;
+  tags?: string;
+  linter?: Linter;
+  unitTestRunner?: UnitTestRunner;
+  e2eTestRunner?: E2eTestRunner;
+  backendProject?: string;
+  strict?: boolean;
+  standaloneConfig?: boolean;
+  inlineStyle?: boolean;
+  inlineTemplate?: boolean;
+  viewEncapsulation?: 'Emulated' | 'Native' | 'None';
+  skipFormat?: boolean;
+  standalone?: boolean;
+  ssr?: boolean;
+  typescriptConfiguration?: boolean;
+}

package/src/generators/remote/schema.json

@@ -0,0 +1,178 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxMFRemote",
+  "cli": "nx",
+  "title": "Nx Module Federation Remote App",
+  "description": "Create an Angular Remote Module Federation Application.",
+  "type": "object",
+  "examples": [
+    {
+      "command": "nx g @nx/angular:remote appName --host=host --port=4201",
+      "description": "Create an Angular app with configuration in place for Module Federation. If host is provided, attach this remote app to host app's configuration."
+    }
+  ],
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "The name to give to the remote Angular app.",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "pattern": "^[a-zA-Z][^:]*$"
+    },
+    "host": {
+      "type": "string",
+      "description": "The name of the host app to attach this remote app to.",
+      "x-dropdown": "projects",
+      "x-priority": "important"
+    },
+    "port": {
+      "type": "number",
+      "description": "The port on which this app should be served."
+    },
+    "directory": {
+      "description": "The directory of the new application.",
+      "type": "string"
+    },
+    "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.",
+      "type": "string",
+      "default": "css",
+      "enum": ["css", "scss", "sass", "less"],
+      "x-prompt": {
+        "message": "Which stylesheet format would you like to use?",
+        "type": "list",
+        "items": [
+          {
+            "value": "css",
+            "label": "CSS"
+          },
+          {
+            "value": "scss",
+            "label": "SASS(.scss)  [ https://sass-lang.com   ]"
+          },
+          {
+            "value": "sass",
+            "label": "SASS(.sass)  [ https://sass-lang.com   ]"
+          },
+          {
+            "value": "less",
+            "label": "LESS         [ https://lesscss.org     ]"
+          }
+        ]
+      }
+    },
+    "inlineStyle": {
+      "description": "Specifies if the style will be in the ts file.",
+      "type": "boolean",
+      "default": false,
+      "alias": "s"
+    },
+    "inlineTemplate": {
+      "description": "Specifies if the template will be in the ts file.",
+      "type": "boolean",
+      "default": false,
+      "alias": "t"
+    },
+    "viewEncapsulation": {
+      "description": "Specifies the view encapsulation strategy.",
+      "enum": ["Emulated", "None", "ShadowDom"],
+      "type": "string"
+    },
+    "prefix": {
+      "type": "string",
+      "format": "html-selector",
+      "description": "The prefix to apply to generated selectors.",
+      "alias": "p"
+    },
+    "skipTests": {
+      "description": "Skip creating spec files.",
+      "type": "boolean",
+      "default": false,
+      "alias": "S"
+    },
+    "skipPackageJson": {
+      "type": "boolean",
+      "default": false,
+      "description": "Do not add dependencies to `package.json`.",
+      "x-priority": "internal"
+    },
+    "unitTestRunner": {
+      "type": "string",
+      "enum": ["jest", "none"],
+      "description": "Test runner to use for unit tests.",
+      "default": "jest"
+    },
+    "e2eTestRunner": {
+      "type": "string",
+      "enum": ["cypress", "playwright", "none"],
+      "description": "Test runner to use for end to end (E2E) tests.",
+      "x-prompt": "Which E2E test runner would you like to use?",
+      "default": "cypress"
+    },
+    "tags": {
+      "type": "string",
+      "description": "Add tags to the application (used for linting)."
+    },
+    "linter": {
+      "description": "The tool to use for running lint checks.",
+      "type": "string",
+      "enum": ["eslint", "none"],
+      "default": "eslint"
+    },
+    "backendProject": {
+      "type": "string",
+      "description": "Backend project that provides data to this application. This sets up `proxy.config.json`."
+    },
+    "strict": {
+      "type": "boolean",
+      "description": "Create an application with stricter type checking and build optimization options.",
+      "default": true
+    },
+    "standaloneConfig": {
+      "description": "Split the project configuration into `<projectRoot>/project.json` rather than including it inside `workspace.json`.",
+      "type": "boolean",
+      "default": true,
+      "x-deprecated": "Nx only supports standaloneConfig"
+    },
+    "setParserOptionsProject": {
+      "type": "boolean",
+      "description": "Whether or not to configure the ESLint `parserOptions.project` option. We do not do this by default for lint performance reasons.",
+      "default": false
+    },
+    "addTailwind": {
+      "type": "boolean",
+      "description": "Whether to configure Tailwind CSS for the application.",
+      "default": false
+    },
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false,
+      "x-priority": "internal"
+    },
+    "standalone": {
+      "description": "Whether to generate a remote application with standalone components.",
+      "type": "boolean",
+      "default": true
+    },
+    "ssr": {
+      "description": "Whether to configure SSR for the remote application to be consumed by a host application using SSR.",
+      "type": "boolean",
+      "default": false
+    },
+    "typescriptConfiguration": {
+      "type": "boolean",
+      "description": "Whether the module federation configuration and webpack configuration files should use TS.",
+      "default": true
+    }
+  },
+  "additionalProperties": false,
+  "required": ["name"]
+}

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

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