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

package/src/generators/utils/testing.js

@@ -0,0 +1,274 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStorybookTestWorkspaceForLib = exports.generateTestLibrary = exports.generateTestRemoteApplication = exports.generateTestHostApplication = exports.generateTestApplication = void 0;
+const devkit_1 = require("@nx/devkit");
+const testing_1 = require("@nx/devkit/testing");
+const eslint_1 = require("@nx/eslint");
+const test_runners_1 = require("../../utils/test-runners");
+const versions_1 = require("../../utils/versions");
+const application_1 = require("../application/application");
+const component_1 = require("../component/component");
+const host_1 = require("../host/host");
+const library_1 = require("../library/library");
+const remote_1 = require("../remote/remote");
+async function generateTestApplication(tree, options) {
+    addAngularPluginPeerDeps(tree);
+    tree.write('.gitignore', '');
+    await (0, application_1.applicationGenerator)(tree, {
+        projectNameAndRootFormat: 'as-provided',
+        ...options,
+    });
+}
+exports.generateTestApplication = generateTestApplication;
+async function generateTestHostApplication(tree, options) {
+    addAngularPluginPeerDeps(tree);
+    tree.write('.gitignore', '');
+    await (0, host_1.host)(tree, { projectNameAndRootFormat: 'as-provided', ...options });
+}
+exports.generateTestHostApplication = generateTestHostApplication;
+async function generateTestRemoteApplication(tree, options) {
+    addAngularPluginPeerDeps(tree);
+    tree.write('.gitignore', '');
+    await (0, remote_1.remote)(tree, { projectNameAndRootFormat: 'as-provided', ...options });
+}
+exports.generateTestRemoteApplication = generateTestRemoteApplication;
+async function generateTestLibrary(tree, options) {
+    addAngularPluginPeerDeps(tree);
+    tree.write('.gitignore', '');
+    await (0, library_1.libraryGenerator)(tree, {
+        projectNameAndRootFormat: 'as-provided',
+        ...options,
+    });
+}
+exports.generateTestLibrary = generateTestLibrary;
+async function createStorybookTestWorkspaceForLib(libName) {
+    let tree = (0, testing_1.createTreeWithEmptyWorkspace)({ layout: 'apps-libs' });
+    addAngularPluginPeerDeps(tree);
+    tree.write('.gitignore', '');
+    await (0, library_1.libraryGenerator)(tree, {
+        name: libName,
+        buildable: false,
+        linter: eslint_1.Linter.EsLint,
+        publishable: false,
+        simpleName: false,
+        skipFormat: true,
+        unitTestRunner: test_runners_1.UnitTestRunner.Jest,
+        projectNameAndRootFormat: 'as-provided',
+        standalone: false,
+    });
+    await (0, component_1.componentGenerator)(tree, {
+        name: 'test-button',
+        project: libName,
+        standalone: false,
+        skipFormat: true,
+    });
+    tree.write(`${libName}/src/lib/test-button/test-button.component.ts`, `import { Component, Input } from '@angular/core';
+
+export type ButtonStyle = 'default' | 'primary' | 'accent';
+
+@Component({
+  selector: 'proj-test-button',
+  templateUrl: './test-button.component.html',
+  styleUrls: ['./test-button.component.css']
+})
+export class TestButtonComponent {
+  @Input('buttonType') type = 'button';
+  @Input() style: ButtonStyle = 'default';
+  @Input() age?: number;
+  @Input() isOn = false;
+}`);
+    tree.write(`${libName}/src/lib/test-button/test-button.component.html`, `<button [attr.type]="type" [ngClass]="style"></button>`);
+    const modulePath = `${libName}/src/lib/${libName}.module.ts`;
+    tree.write(modulePath, `import * as ButtonExports from './test-button/test-button.component';
+    ${tree.read(modulePath)}`);
+    // create a module with component that gets exported in a barrel file
+    generateModule(tree, {
+        name: 'barrel',
+        project: libName,
+    });
+    await (0, component_1.componentGenerator)(tree, {
+        name: 'barrel-button',
+        project: libName,
+        path: `${libName}/src/lib/barrel`,
+        module: 'barrel',
+        standalone: false,
+        skipFormat: true,
+    });
+    tree.write(`${libName}/src/lib/barrel/barrel-button/index.ts`, `export * from './barrel-button.component';`);
+    tree.write(`${libName}/src/lib/barrel/barrel.module.ts`, `import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { BarrelButtonComponent } from './barrel-button';
+
+@NgModule({
+  imports: [CommonModule],
+  declarations: [BarrelButtonComponent],
+})
+export class BarrelModule {}`);
+    // create a module with components that get Angular exported and declared by variable
+    generateModule(tree, {
+        name: 'variable-declare',
+        project: libName,
+    });
+    await (0, component_1.componentGenerator)(tree, {
+        name: 'variable-declare-button',
+        project: libName,
+        path: `${libName}/src/lib/variable-declare`,
+        module: 'variable-declare',
+        standalone: false,
+        skipFormat: true,
+    });
+    await (0, component_1.componentGenerator)(tree, {
+        name: 'variable-declare-view',
+        project: libName,
+        path: `${libName}/src/lib/variable-declare`,
+        module: 'variable-declare',
+        standalone: false,
+        skipFormat: true,
+    });
+    tree.write(`${libName}/src/lib/variable-declare/variable-declare.module.ts`, `import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { VariableDeclareButtonComponent } from './variable-declare-button/variable-declare-button.component';
+import { VariableDeclareViewComponent } from './variable-declare-view/variable-declare-view.component';
+
+const COMPONENTS = [
+  VariableDeclareButtonComponent,
+  VariableDeclareViewComponent
+]
+
+@NgModule({
+  imports: [CommonModule],
+  declarations: COMPONENTS,
+  exports: COMPONENTS
+})
+export class VariableDeclareModule {}`);
+    // create a module with components that get Angular exported and declared by variable
+    generateModule(tree, {
+        name: 'variable-spread-declare',
+        project: libName,
+    });
+    await (0, component_1.componentGenerator)(tree, {
+        name: 'variable-spread-declare-button',
+        project: libName,
+        path: `${libName}/src/lib/variable-spread-declare`,
+        module: 'variable-spread-declare',
+        standalone: false,
+        skipFormat: true,
+    });
+    await (0, component_1.componentGenerator)(tree, {
+        name: 'variable-spread-declare-view',
+        project: libName,
+        path: `${libName}/src/lib/variable-spread-declare`,
+        module: 'variable-spread-declare',
+        standalone: false,
+        skipFormat: true,
+    });
+    await (0, component_1.componentGenerator)(tree, {
+        name: 'variable-spread-declare-anotherview',
+        project: libName,
+        path: `${libName}/src/lib/variable-spread-declare`,
+        module: 'variable-spread-declare',
+        standalone: false,
+        skipFormat: true,
+    });
+    tree.write(`${libName}/src/lib/variable-spread-declare/variable-spread-declare.module.ts`, `import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { VariableSpreadDeclareButtonComponent } from './variable-spread-declare-button/variable-spread-declare-button.component';
+import { VariableSpreadDeclareViewComponent } from './variable-spread-declare-view/variable-spread-declare-view.component';
+import { VariableSpreadDeclareAnotherviewComponent } from './variable-spread-declare-anotherview/variable-spread-declare-anotherview.component';
+
+const COMPONENTS = [
+  VariableSpreadDeclareButtonComponent,
+  VariableSpreadDeclareViewComponent
+]
+
+@NgModule({
+  imports: [CommonModule],
+  declarations: [...COMPONENTS, VariableSpreadDeclareAnotherviewComponent],
+})
+export class VariableSpreadDeclareModule {}`);
+    // create a module where declared components are pulled from a static member of the module
+    generateModule(tree, {
+        name: 'static-member-declarations',
+        project: libName,
+    });
+    await (0, component_1.componentGenerator)(tree, {
+        name: 'cmp1',
+        project: libName,
+        path: `${libName}/src/lib/static-member-declarations`,
+        module: 'static-member-declarations',
+        standalone: false,
+        skipFormat: true,
+    });
+    await (0, component_1.componentGenerator)(tree, {
+        name: 'cmp2',
+        project: libName,
+        path: `${libName}/src/lib/static-member-declarations`,
+        module: 'static-member-declarations',
+        standalone: false,
+        skipFormat: true,
+    });
+    tree.write(`${libName}/src/lib/static-member-declarations/static-member-declarations.module.ts`, `import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { Cmp1Component } from './cmp1/cmp1.component';
+import { Cmp2Component } from './cmp2/cmp2.component';
+
+@NgModule({
+  imports: [CommonModule],
+  declarations: StaticMemberDeclarationsModule.COMPONENTS,
+  exports: StaticMemberDeclarationsModule.COMPONENTS
+})
+export class StaticMemberDeclarationsModule {
+  static readonly COMPONENTS = [Cmp1Component, Cmp2Component];
+}`);
+    // create another button in a nested subpath
+    generateModule(tree, {
+        name: 'nested',
+        project: libName,
+        path: `${libName}/src/lib`,
+    });
+    await (0, component_1.componentGenerator)(tree, {
+        name: 'nested-button',
+        project: libName,
+        module: 'nested',
+        path: `${libName}/src/lib/nested`,
+        standalone: false,
+        skipFormat: true,
+    });
+    await (0, component_1.componentGenerator)(tree, {
+        name: 'test-other',
+        project: libName,
+        standalone: false,
+        skipFormat: true,
+    });
+    return tree;
+}
+exports.createStorybookTestWorkspaceForLib = createStorybookTestWorkspaceForLib;
+function addAngularPluginPeerDeps(tree) {
+    (0, devkit_1.updateJson)(tree, 'package.json', (json) => ({
+        ...json,
+        devDependencies: {
+            ...json.devDependencies,
+            '@angular-devkit/core': versions_1.angularDevkitVersion,
+            '@angular-devkit/schematics': versions_1.angularDevkitVersion,
+            '@schematics/angular': versions_1.angularDevkitVersion,
+        },
+    }));
+}
+function generateModule(tree, options) {
+    const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    if (options.path === undefined) {
+        const sourceRoot = project.sourceRoot ?? `${project.root}/src`;
+        const projectDirName = project.projectType === 'application' ? 'app' : 'lib';
+        options.path = `${sourceRoot}/${projectDirName}`;
+    }
+    const moduleNames = (0, devkit_1.names)(options.name);
+    const moduleFilePath = `${options.path}/${moduleNames.fileName}/${moduleNames.fileName}.module.ts`;
+    tree.write(moduleFilePath, `import { NgModule } from '@angular/core';
+  import { CommonModule } from '@angular/common';
+
+  @NgModule({
+    declarations: [],
+    imports: [CommonModule],
+  })
+  export class ${moduleNames.className}Module {}`);
+}

package/src/generators/utils/types.d.ts

@@ -0,0 +1 @@
+export type Styles = 'css' | 'less' | 'scss' | 'sass';

package/src/generators/utils/types.js

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

package/src/generators/utils/update-app-editor-tsconfig-excluded-files.d.ts

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

package/src/generators/utils/update-app-editor-tsconfig-excluded-files.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateAppEditorTsConfigExcludedFiles = void 0;
+const devkit_1 = require("@nx/devkit");
+function updateAppEditorTsConfigExcludedFiles(tree, projectConfig) {
+    if (projectConfig.projectType !== 'application') {
+        return;
+    }
+    const editorTsConfigPath = (0, devkit_1.joinPathFragments)(projectConfig.root, 'tsconfig.editor.json');
+    const appTsConfigPath = (0, devkit_1.joinPathFragments)(projectConfig.root, 'tsconfig.app.json');
+    if (!tree.exists(editorTsConfigPath) || !tree.exists(appTsConfigPath)) {
+        return;
+    }
+    const appTsConfig = (0, devkit_1.readJson)(tree, appTsConfigPath);
+    (0, devkit_1.updateJson)(tree, editorTsConfigPath, (json) => {
+        const exclude = [...(json.exclude ?? []), ...(appTsConfig.exclude ?? [])];
+        if (exclude.length) {
+            json.exclude = Array.from(new Set(exclude));
+        }
+        return json;
+    });
+}
+exports.updateAppEditorTsConfigExcludedFiles = updateAppEditorTsConfigExcludedFiles;

package/src/generators/utils/update-project-root-tsconfig.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+export { extractTsConfigBase } from '@nx/js';
+export declare function updateProjectRootTsConfig(host: Tree, projectRoot: string, relativePathToRootTsConfig: string, isRootProject?: boolean): void;

package/src/generators/utils/update-project-root-tsconfig.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateProjectRootTsConfig = exports.extractTsConfigBase = void 0;
+const devkit_1 = require("@nx/devkit");
+const js_1 = require("@nx/js");
+var js_2 = require("@nx/js");
+Object.defineProperty(exports, "extractTsConfigBase", { enumerable: true, get: function () { return js_2.extractTsConfigBase; } });
+function updateProjectRootTsConfig(host, projectRoot, relativePathToRootTsConfig, isRootProject) {
+    (0, devkit_1.updateJson)(host, `${projectRoot}/tsconfig.json`, (json) => {
+        if (isRootProject) {
+            // inline tsconfig.base.json into the project
+            json.compileOnSave = false;
+            json.compilerOptions = {
+                ...js_1.tsConfigBaseOptions,
+                ...json.compilerOptions,
+            };
+            json.exclude = ['node_modules', 'tmp'];
+            delete json.extends;
+        }
+        else {
+            json.extends = relativePathToRootTsConfig;
+        }
+        return json;
+    });
+}
+exports.updateProjectRootTsConfig = updateProjectRootTsConfig;

package/src/generators/utils/validations.d.ts

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

package/src/generators/utils/validations.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateProject = void 0;
+const devkit_1 = require("@nx/devkit");
+function validateProject(tree, projectName) {
+    const projects = (0, devkit_1.getProjects)(tree);
+    if (!projects.has(projectName)) {
+        throw new Error(`Project "${projectName}" does not exist! Please provide an existing project name.`);
+    }
+}
+exports.validateProject = validateProject;

package/src/generators/utils/version-utils.d.ts

@@ -0,0 +1,15 @@
+import type { GeneratorCallback, Tree } from '@nx/devkit';
+import { type PackageCompatVersions, type PackageLatestVersions } from '../../utils/backward-compatible-versions';
+export declare function getInstalledAngularVersion(tree: Tree): string;
+export declare function getInstalledAngularMajorVersion(tree: Tree): number;
+export declare function getInstalledAngularVersionInfo(tree: Tree): {
+    version: string;
+    major: number;
+};
+export declare function getInstalledPackageVersion(tree: Tree, pkgName: string): string | null;
+export declare function getInstalledPackageVersionInfo(tree: Tree, pkgName: string): {
+    major: number;
+    version: string;
+};
+export declare function addDependenciesToPackageJsonIfDontExist(tree: Tree, dependencies: Record<string, string>, devDependencies: Record<string, string>, packageJsonPath?: string): GeneratorCallback;
+export declare function versions(tree: Tree): PackageLatestVersions | PackageCompatVersions;

package/src/generators/utils/version-utils.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.versions = exports.addDependenciesToPackageJsonIfDontExist = exports.getInstalledPackageVersionInfo = exports.getInstalledPackageVersion = exports.getInstalledAngularVersionInfo = exports.getInstalledAngularMajorVersion = exports.getInstalledAngularVersion = void 0;
+const devkit_1 = require("@nx/devkit");
+const semver_1 = require("semver");
+const backward_compatible_versions_1 = require("../../utils/backward-compatible-versions");
+const latestVersions = require("../../utils/versions");
+const versions_1 = require("../../utils/versions");
+function getInstalledAngularVersion(tree) {
+    const pkgJson = (0, devkit_1.readJson)(tree, 'package.json');
+    const installedAngularVersion = pkgJson.dependencies && pkgJson.dependencies['@angular/core'];
+    if (!installedAngularVersion ||
+        installedAngularVersion === 'latest' ||
+        installedAngularVersion === 'next') {
+        return (0, semver_1.clean)(versions_1.angularVersion) ?? (0, semver_1.coerce)(versions_1.angularVersion).version;
+    }
+    return ((0, semver_1.clean)(installedAngularVersion) ?? (0, semver_1.coerce)(installedAngularVersion).version);
+}
+exports.getInstalledAngularVersion = getInstalledAngularVersion;
+function getInstalledAngularMajorVersion(tree) {
+    return (0, semver_1.major)(getInstalledAngularVersion(tree));
+}
+exports.getInstalledAngularMajorVersion = getInstalledAngularMajorVersion;
+function getInstalledAngularVersionInfo(tree) {
+    const installedVersion = getInstalledAngularVersion(tree);
+    return {
+        version: installedVersion,
+        major: (0, semver_1.major)(installedVersion),
+    };
+}
+exports.getInstalledAngularVersionInfo = getInstalledAngularVersionInfo;
+function getInstalledPackageVersion(tree, pkgName) {
+    const { dependencies, devDependencies } = (0, devkit_1.readJson)(tree, 'package.json');
+    const version = dependencies?.[pkgName] ?? devDependencies?.[pkgName];
+    return version;
+}
+exports.getInstalledPackageVersion = getInstalledPackageVersion;
+function getInstalledPackageVersionInfo(tree, pkgName) {
+    const version = getInstalledPackageVersion(tree, pkgName);
+    return version ? { major: (0, semver_1.major)((0, semver_1.coerce)(version)), version } : null;
+}
+exports.getInstalledPackageVersionInfo = getInstalledPackageVersionInfo;
+function addDependenciesToPackageJsonIfDontExist(tree, dependencies, devDependencies, packageJsonPath = 'package.json') {
+    const packageJson = (0, devkit_1.readJson)(tree, packageJsonPath);
+    function filterExisting(deps) {
+        return Object.keys(deps)
+            .filter((d) => !packageJson.dependencies?.[d] && !packageJson.devDependencies?.[d])
+            .reduce((acc, d) => ({ ...acc, [d]: deps[d] }), {});
+    }
+    const depsToAdd = filterExisting(dependencies);
+    const devDepsToAdd = filterExisting(devDependencies);
+    return (0, devkit_1.addDependenciesToPackageJson)(tree, depsToAdd, devDepsToAdd, packageJsonPath);
+}
+exports.addDependenciesToPackageJsonIfDontExist = addDependenciesToPackageJsonIfDontExist;
+function versions(tree) {
+    const majorAngularVersion = getInstalledAngularMajorVersion(tree);
+    switch (majorAngularVersion) {
+        case 15:
+            return backward_compatible_versions_1.backwardCompatibleVersions.angularV15;
+        case 16:
+            return backward_compatible_versions_1.backwardCompatibleVersions.angularV16;
+        default:
+            return latestVersions;
+    }
+}
+exports.versions = versions;

package/src/generators/web-worker/files/config/tsconfig.worker.json__tpl__

@@ -0,0 +1,14 @@
+{
+  "extends": "<%= rootTsConfig %>",
+  "compilerOptions": {
+    "outDir": "<%= rootOffset %>/out-tsc/worker",
+    "lib": [
+      "es2018",
+      "webworker"
+    ],
+    "types": []
+  },
+  "include": [
+    "src/**/*.worker.ts"
+  ]
+}

package/src/generators/web-worker/files/worker/__name__.worker.ts__tpl__

@@ -0,0 +1,6 @@
+/// <reference lib="webworker" />
+
+addEventListener('message', ({ data }) => {
+  const response = `worker response to ${data}`;
+  postMessage(response);
+});

package/src/generators/web-worker/lib/add-snippet.d.ts

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

package/src/generators/web-worker/lib/add-snippet.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addSnippet = void 0;
+const devkit_1 = require("@nx/devkit");
+function addSnippet(tree, name, path) {
+    const fileRegExp = new RegExp(`^${name}.*\\.ts`);
+    const children = tree.children(path);
+    const siblingModules = children
+        .filter((f) => fileRegExp.test(f) && !/(module|spec)\.ts$/.test(f))
+        .sort();
+    if (siblingModules.length === 0) {
+        return;
+    }
+    const siblingModulePath = (0, devkit_1.joinPathFragments)(path, siblingModules[0]);
+    const logMessage = 'console.log(`page got message ${data}`);';
+    const workerCreationSnippet = (0, devkit_1.stripIndents) `
+      if (typeof Worker !== 'undefined') {
+        // Create a new
+        const worker = new Worker(new URL('./${name}.worker', import.meta.url));
+        worker.onmessage = ({ data }) => {
+          ${logMessage}
+        };
+        worker.postMessage('hello');
+      } else {
+        // Web Workers are not supported in this environment.
+        // You should add a fallback so that your program still executes correctly.
+      }
+    `;
+    const originalContent = tree.read(siblingModulePath, 'utf-8');
+    tree.write(siblingModulePath, (0, devkit_1.stripIndents) `${originalContent}
+  ${workerCreationSnippet}`);
+}
+exports.addSnippet = addSnippet;

package/src/generators/web-worker/lib/index.d.ts

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

package/src/generators/web-worker/lib/index.js

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

package/src/generators/web-worker/lib/normalize-options.d.ts

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

package/src/generators/web-worker/lib/normalize-options.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeOptions = void 0;
+const devkit_1 = require("@nx/devkit");
+function normalizeOptions(tree, options) {
+    if (!(0, devkit_1.getProjects)(tree).has(options.project)) {
+        throw new Error(`Project '${options.project}' does not exist!`);
+    }
+    const { projectType, sourceRoot, root } = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    if (projectType !== 'application') {
+        throw new Error(`Web Worker can only be added to an application. Project '${options.project}' is a library.`);
+    }
+    const path = options.path ?? sourceRoot
+        ? (0, devkit_1.joinPathFragments)(sourceRoot, 'app')
+        : (0, devkit_1.joinPathFragments)(root, 'src', 'app');
+    if (!tree.exists(path)) {
+        throw new Error(`Path '${options.path}' does not exist!`);
+    }
+    return {
+        ...options,
+        path,
+        snippet: options.snippet ?? true,
+    };
+}
+exports.normalizeOptions = normalizeOptions;

package/src/generators/web-worker/schema.d.ts

@@ -0,0 +1,7 @@
+export interface WebWorkerGeneratorOptions {
+  name: string;
+  project: string;
+  path?: string;
+  skipFormat?: boolean;
+  snippet?: boolean;
+}

package/src/generators/web-worker/schema.json

@@ -0,0 +1,48 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "NxAngularWebWorkerGenerator",
+  "title": "Angular Web Worker Options Schema",
+  "description": "Creates a new, generic web worker definition in the given or default project.",
+  "cli": "nx",
+  "type": "object",
+  "properties": {
+    "path": {
+      "type": "string",
+      "format": "path",
+      "description": "The path at which to create the worker file, relative to the current workspace."
+    },
+    "project": {
+      "type": "string",
+      "description": "The name of the project.",
+      "$default": {
+        "$source": "projectName"
+      },
+      "x-dropdown": "projects",
+      "x-priority": "important"
+    },
+    "name": {
+      "type": "string",
+      "description": "The name of the worker.",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "What name would you like to use for the worker?",
+      "x-priority": "important"
+    },
+    "snippet": {
+      "type": "boolean",
+      "default": true,
+      "description": "Add a worker creation snippet in a sibling file of the same name."
+    },
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false,
+      "x-priority": "internal"
+    }
+  },
+  "additionalProperties": false,
+  "required": ["name", "project"],
+  "examplesFile": "../../../docs/web-worker-examples.md"
+}

package/src/generators/web-worker/web-worker.d.ts

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

package/src/generators/web-worker/web-worker.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webWorkerGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+const lib_1 = require("./lib");
+const js_1 = require("@nx/js");
+async function webWorkerGenerator(tree, rawOptions) {
+    const options = (0, lib_1.normalizeOptions)(tree, rawOptions);
+    const workerNames = (0, devkit_1.names)(options.name);
+    const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    const substitutions = {
+        rootOffset: (0, devkit_1.offsetFromRoot)(projectConfig.root),
+        rootTsConfig: (0, js_1.getRelativePathToRootTsConfig)(tree, projectConfig.root),
+        name: workerNames.fileName,
+        tpl: '',
+    };
+    (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, './files/worker'), options.path, substitutions);
+    (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, './files/config'), projectConfig.root, substitutions);
+    if (options.snippet) {
+        (0, lib_1.addSnippet)(tree, workerNames.fileName, options.path);
+    }
+    projectConfig.targets['build'].options.webWorkerTsConfig ??=
+        (0, devkit_1.joinPathFragments)(projectConfig.root, 'tsconfig.worker.json');
+    if (projectConfig.targets['test']) {
+        projectConfig.targets['test'].options.webWorkerTsConfig ??=
+            (0, devkit_1.joinPathFragments)(projectConfig.root, 'tsconfig.worker.json');
+    }
+    (0, devkit_1.updateProjectConfiguration)(tree, options.project, projectConfig);
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+}
+exports.webWorkerGenerator = webWorkerGenerator;
+exports.default = webWorkerGenerator;

package/src/migrations/update-14-2-0/remove-show-circular-dependencies-option.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export default function (tree: Tree): Promise<void>;