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

package/src/generators/guard/schema.json

@@ -0,0 +1,63 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxNestGuardGenerator",
+  "title": "Nest Guard Options Schema",
+  "description": "Nest Guard Options Schema.",
+  "cli": "nx",
+  "type": "object",
+  "properties": {
+    "name": {
+      "description": "The name of the guard.",
+      "type": "string",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "What name would you like to use?"
+    },
+    "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": {
+      "description": "The Nest project to target.",
+      "type": "string",
+      "$default": {
+        "$source": "projectName"
+      },
+      "alias": "p",
+      "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."
+    },
+    "directory": {
+      "description": "Directory where the generated files are placed. when `--nameAndDirectoryFormat=as-provided`, it will be relative to the current working directory. otherwise, it will be relative to the workspace root.",
+      "type": "string",
+      "aliases": ["dir", "path"]
+    },
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false,
+      "x-priority": "internal"
+    },
+    "unitTestRunner": {
+      "description": "Test runner to use for unit tests.",
+      "type": "string",
+      "enum": ["jest", "none"],
+      "default": "jest"
+    },
+    "flat": {
+      "description": "Flag to indicate if a directory is created.",
+      "x-deprecated": "Provide the `directory` option instead and use the `as-provided` format. It will be removed in Nx v19.",
+      "type": "boolean",
+      "default": true
+    },
+    "language": {
+      "description": "Nest guard language.",
+      "type": "string",
+      "enum": ["js", "ts"]
+    }
+  },
+  "additionalProperties": false,
+  "required": ["name"]
+}

package/src/generators/init/init.d.ts

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

package/src/generators/init/init.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+const lib_1 = require("./lib");
+async function initGenerator(tree, options) {
+    let installPackagesTask = () => { };
+    if (!options.skipPackageJson) {
+        installPackagesTask = (0, lib_1.addDependencies)(tree, options);
+    }
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return installPackagesTask;
+}
+exports.initGenerator = initGenerator;
+exports.default = initGenerator;

package/src/generators/init/lib/add-dependencies.d.ts

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

package/src/generators/init/lib/add-dependencies.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addDependencies = void 0;
+const devkit_1 = require("@nx/devkit");
+const versions_1 = require("../../../utils/versions");
+function addDependencies(tree, options) {
+    return (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+        '@nestjs/schematics': versions_1.nestJsSchematicsVersion,
+        '@nx/nest': versions_1.nxVersion,
+    }, undefined, options.keepExistingVersions);
+}
+exports.addDependencies = addDependencies;

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

@@ -0,0 +1 @@
+export * from './add-dependencies';

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

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

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

@@ -0,0 +1,7 @@
+import { UnitTestRunner } from '../utils';
+
+export interface InitGeneratorOptions {
+  skipFormat?: boolean;
+  skipPackageJson?: boolean;
+  keepExistingVersions?: boolean;
+}

package/src/generators/init/schema.json

@@ -0,0 +1,28 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxNestInitGenerator",
+  "title": "Init Nest Plugin",
+  "description": "Init Nest Plugin.",
+  "cli": "nx",
+  "type": "object",
+  "properties": {
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false
+    },
+    "skipPackageJson": {
+      "description": "Do not add dependencies to `package.json`.",
+      "type": "boolean",
+      "default": false,
+      "x-priority": "internal"
+    },
+    "keepExistingVersions": {
+      "type": "boolean",
+      "x-priority": "internal",
+      "description": "Keep existing dependencies versions",
+      "default": false
+    }
+  },
+  "required": []
+}

package/src/generators/interceptor/interceptor.d.ts

@@ -0,0 +1,6 @@
+import type { Tree } from '@nx/devkit';
+import type { NestGeneratorWithLanguageOption, NestGeneratorWithTestOption } from '../utils';
+export type InterceptorGeneratorOptions = NestGeneratorWithLanguageOption & NestGeneratorWithTestOption;
+export declare function interceptorGenerator(tree: Tree, rawOptions: InterceptorGeneratorOptions): Promise<void>;
+export declare function interceptorGeneratorInternal(tree: Tree, rawOptions: InterceptorGeneratorOptions): Promise<any>;
+export default interceptorGenerator;

package/src/generators/interceptor/interceptor.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interceptorGeneratorInternal = exports.interceptorGenerator = void 0;
+const utils_1 = require("../utils");
+async function interceptorGenerator(tree, rawOptions) {
+    await interceptorGeneratorInternal(tree, {
+        nameAndDirectoryFormat: 'derived',
+        ...rawOptions,
+    });
+}
+exports.interceptorGenerator = interceptorGenerator;
+async function interceptorGeneratorInternal(tree, rawOptions) {
+    const options = await normalizeInterceptorOptions(tree, rawOptions);
+    return (0, utils_1.runNestSchematic)(tree, 'interceptor', options);
+}
+exports.interceptorGeneratorInternal = interceptorGeneratorInternal;
+exports.default = interceptorGenerator;
+async function normalizeInterceptorOptions(tree, options) {
+    const normalizedOptions = await (0, utils_1.normalizeOptions)(tree, 'interceptor', '@nx/nest:interceptor', options);
+    return {
+        ...normalizedOptions,
+        language: options.language,
+        spec: (0, utils_1.unitTestRunnerToSpec)(options.unitTestRunner),
+    };
+}

package/src/generators/interceptor/schema.json

@@ -0,0 +1,63 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxNestInterceptorGenerator",
+  "title": "Nest Interceptor Options Schema",
+  "description": "Nest Interceptor Options Schema.",
+  "cli": "nx",
+  "type": "object",
+  "properties": {
+    "name": {
+      "description": "The name of the interceptor.",
+      "type": "string",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "What name would you like to use?"
+    },
+    "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": {
+      "description": "The Nest project to target.",
+      "type": "string",
+      "$default": {
+        "$source": "projectName"
+      },
+      "alias": "p",
+      "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."
+    },
+    "directory": {
+      "description": "Directory where the generated files are placed. when `--nameAndDirectoryFormat=as-provided`, it will be relative to the current working directory. otherwise, it will be relative to the workspace root.",
+      "type": "string",
+      "aliases": ["dir", "path"]
+    },
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false,
+      "x-priority": "internal"
+    },
+    "unitTestRunner": {
+      "description": "Test runner to use for unit tests.",
+      "type": "string",
+      "enum": ["jest", "none"],
+      "default": "jest"
+    },
+    "flat": {
+      "description": "Flag to indicate if a directory is created.",
+      "x-deprecated": "Provide the `directory` option instead and use the `as-provided` format. It will be removed in Nx v19.",
+      "type": "boolean",
+      "default": true
+    },
+    "language": {
+      "description": "Nest interceptor language.",
+      "type": "string",
+      "enum": ["js", "ts"]
+    }
+  },
+  "additionalProperties": false,
+  "required": ["name"]
+}

package/src/generators/interface/interface.d.ts

@@ -0,0 +1,6 @@
+import type { Tree } from '@nx/devkit';
+import type { NestGeneratorOptions } from '../utils';
+export type InterfaceGeneratorOptions = NestGeneratorOptions;
+export declare function interfaceGenerator(tree: Tree, rawOptions: InterfaceGeneratorOptions): Promise<void>;
+export declare function interfaceGeneratorInternal(tree: Tree, rawOptions: InterfaceGeneratorOptions): Promise<any>;
+export default interfaceGenerator;

package/src/generators/interface/interface.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interfaceGeneratorInternal = exports.interfaceGenerator = void 0;
+const utils_1 = require("../utils");
+async function interfaceGenerator(tree, rawOptions) {
+    await interfaceGeneratorInternal(tree, {
+        nameAndDirectoryFormat: 'derived',
+        ...rawOptions,
+    });
+}
+exports.interfaceGenerator = interfaceGenerator;
+async function interfaceGeneratorInternal(tree, rawOptions) {
+    const options = await (0, utils_1.normalizeOptions)(tree, 'interface', '@nx/nest:interface', rawOptions);
+    return (0, utils_1.runNestSchematic)(tree, 'interface', options);
+}
+exports.interfaceGeneratorInternal = interfaceGeneratorInternal;
+exports.default = interfaceGenerator;

package/src/generators/interface/schema.json

@@ -0,0 +1,52 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxNestInterfaceGenerator",
+  "title": "Nest Interface Options Schema",
+  "description": "Nest Interface Options Schema.",
+  "cli": "nx",
+  "type": "object",
+  "properties": {
+    "name": {
+      "description": "The name of the interface.",
+      "type": "string",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "What name would you like to use?"
+    },
+    "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": {
+      "description": "The Nest project to target.",
+      "type": "string",
+      "$default": {
+        "$source": "projectName"
+      },
+      "alias": "p",
+      "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."
+    },
+    "directory": {
+      "description": "Directory where the generated files are placed. when `--nameAndDirectoryFormat=as-provided`, it will be relative to the current working directory. otherwise, it will be relative to the workspace root.",
+      "type": "string",
+      "aliases": ["dir", "path"]
+    },
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false,
+      "x-priority": "internal"
+    },
+    "flat": {
+      "description": "Flag to indicate if a directory is created.",
+      "x-deprecated": "Provide the `directory` option instead and use the `as-provided` format. It will be removed in Nx v19.",
+      "type": "boolean",
+      "default": true
+    }
+  },
+  "additionalProperties": false,
+  "required": ["name"]
+}

package/src/generators/library/files/common/src/lib/__fileName__.module.ts__tmpl__

@@ -0,0 +1,11 @@
+import { Module<% if(global) { %>, Global<% } %> } from '@nestjs/common';<% if(controller) { %>
+import { <%= className %>Controller } from './<%= fileName %>.controller';<% } %><% if(service) { %>
+import { <%= className %>Service } from './<%= fileName %>.service';<% } %>
+<% if(global) { %>
+@Global()<% } %>
+@Module({
+	controllers: [<% if(controller) { %><%= className %>Controller<% } %>],
+	providers: [<% if(service) { %><%= className %>Service<% } %>],
+	exports: [<% if(service) { %><%= className %>Service<% } %>],
+})
+export class <%= className %>Module {}

package/src/generators/library/files/controller/src/lib/__fileName__.controller.spec.ts__tmpl__

@@ -0,0 +1,20 @@
+import { Test } from '@nestjs/testing';
+import { <%= className %>Controller } from './<%= fileName %>.controller';<% if(service) { %>
+import { <%= className %>Service } from './<%= fileName %>.service';<% } %>
+
+describe('<%= className %>Controller', () => {
+	let controller: <%= className %>Controller;
+
+	beforeEach(async () => {
+		const module = await Test.createTestingModule({
+			providers: [<% if(service) { %><%= className %>Service<% } %>],
+			controllers: [<%= className %>Controller]
+		}).compile();
+
+		controller = module.get(<%= className %>Controller);
+	});
+
+	it('should be defined', () => {
+		expect(controller).toBeTruthy();
+	});
+})

package/src/generators/library/files/controller/src/lib/__fileName__.controller.ts__tmpl__

@@ -0,0 +1,7 @@
+import { Controller } from '@nestjs/common';<% if(service) { %>
+import { <%= className %>Service } from './<%= fileName %>.service';<% } %>
+
+@Controller('<%= fileName %>')
+export class <%= className %>Controller {<% if(service) { %>
+  constructor(private <%= propertyName %>Service: <%= className %>Service) {}
+<% } %>}

package/src/generators/library/files/service/src/lib/__fileName__.service.spec.ts__tmpl__

@@ -0,0 +1,18 @@
+import { Test } from '@nestjs/testing';
+import { <%= className %>Service } from './<%= fileName %>.service';
+
+describe('<%= className %>Service', () => {
+  let service: <%= className %>Service;
+
+  beforeEach(async () => {
+    const module = await Test.createTestingModule({
+      providers: [<%= className %>Service]
+    }).compile();
+
+    service = module.get(<%= className %>Service);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeTruthy();
+  });
+})

package/src/generators/library/files/service/src/lib/__fileName__.service.ts__tmpl__

@@ -0,0 +1,4 @@
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class <%= className %>Service {}

package/src/generators/library/lib/add-exports-to-barrel.d.ts

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

package/src/generators/library/lib/add-exports-to-barrel.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addExportsToBarrelFile = void 0;
+const js_1 = require("@nx/js");
+const ensure_typescript_1 = require("@nx/js/src/utils/typescript/ensure-typescript");
+let tsModule;
+function addExportsToBarrelFile(tree, options) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const indexPath = `${options.projectRoot}/src/index.ts`;
+    const indexContent = tree.read(indexPath, 'utf-8');
+    let sourceFile = tsModule.createSourceFile(indexPath, indexContent, tsModule.ScriptTarget.Latest, true);
+    // find the export in the source file
+    const exportStatement = sourceFile.statements.find((statement) => tsModule.isExportDeclaration(statement));
+    sourceFile = (0, js_1.removeChange)(tree, sourceFile, indexPath, 0, exportStatement.getFullText());
+    sourceFile = (0, js_1.addGlobal)(tree, sourceFile, indexPath, `export * from './lib/${options.fileName}.module';`);
+    if (options.service) {
+        sourceFile = (0, js_1.addGlobal)(tree, sourceFile, indexPath, `export * from './lib/${options.fileName}.service';`);
+    }
+    if (options.controller) {
+        sourceFile = (0, js_1.addGlobal)(tree, sourceFile, indexPath, `export * from './lib/${options.fileName}.controller';`);
+    }
+}
+exports.addExportsToBarrelFile = addExportsToBarrelFile;

package/src/generators/library/lib/add-project.d.ts

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

package/src/generators/library/lib/add-project.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addProject = void 0;
+const devkit_1 = require("@nx/devkit");
+function addProject(tree, options) {
+    if (!options.publishable && !options.buildable) {
+        return;
+    }
+    const project = (0, devkit_1.readProjectConfiguration)(tree, options.projectName);
+    project.targets.build = {
+        executor: '@nx/js:tsc',
+        outputs: ['{options.outputPath}'],
+        options: {
+            outputPath: `dist/${options.projectRoot}`,
+            tsConfig: `${options.projectRoot}/tsconfig.lib.json`,
+            packageJson: `${options.projectRoot}/package.json`,
+            main: `${options.projectRoot}/src/index.ts`,
+            assets: [`${options.projectRoot}/*.md`],
+        },
+    };
+    (0, devkit_1.updateProjectConfiguration)(tree, options.projectName, project);
+}
+exports.addProject = addProject;

package/src/generators/library/lib/create-files.d.ts

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

package/src/generators/library/lib/create-files.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFiles = void 0;
+const devkit_1 = require("@nx/devkit");
+function createFiles(tree, options) {
+    const substitutions = {
+        ...options,
+        ...(0, devkit_1.names)(options.projectName),
+        tmpl: '',
+        offsetFromRoot: (0, devkit_1.offsetFromRoot)(options.projectRoot),
+        fileName: options.fileName,
+    };
+    (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, '..', 'files', 'common'), options.projectRoot, substitutions);
+    if (options.controller) {
+        (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, '..', 'files', 'controller'), options.projectRoot, substitutions);
+        if (options.unitTestRunner === 'none') {
+            tree.delete((0, devkit_1.joinPathFragments)(options.projectRoot, 'src', 'lib', `${substitutions.fileName}.controller.spec.ts`));
+        }
+    }
+    if (options.service) {
+        (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, '..', 'files', 'service'), options.projectRoot, substitutions);
+        if (options.unitTestRunner === 'none') {
+            tree.delete((0, devkit_1.joinPathFragments)(options.projectRoot, 'src', 'lib', `${substitutions.fileName}.service.spec.ts`));
+        }
+    }
+}
+exports.createFiles = createFiles;

package/src/generators/library/lib/delete-files.d.ts

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

package/src/generators/library/lib/delete-files.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteFiles = void 0;
+const devkit_1 = require("@nx/devkit");
+function deleteFiles(tree, options) {
+    tree.delete((0, devkit_1.joinPathFragments)(options.projectRoot, 'src', 'lib', `${options.fileName}.ts`));
+    if (options.unitTestRunner !== 'none') {
+        tree.delete((0, devkit_1.joinPathFragments)(options.projectRoot, 'src', 'lib', `${options.fileName}.spec.ts`));
+    }
+    if (!options.buildable && !options.publishable) {
+        tree.delete((0, devkit_1.joinPathFragments)(options.projectRoot, 'package.json'));
+    }
+}
+exports.deleteFiles = deleteFiles;

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

@@ -0,0 +1,6 @@
+export * from './add-exports-to-barrel';
+export * from './add-project';
+export * from './create-files';
+export * from './delete-files';
+export * from './normalize-options';
+export * from './update-tsconfig';

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./add-exports-to-barrel"), exports);
+tslib_1.__exportStar(require("./add-project"), exports);
+tslib_1.__exportStar(require("./create-files"), exports);
+tslib_1.__exportStar(require("./delete-files"), exports);
+tslib_1.__exportStar(require("./normalize-options"), exports);
+tslib_1.__exportStar(require("./update-tsconfig"), exports);

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

@@ -0,0 +1,5 @@
+import { Tree } from '@nx/devkit';
+import type { LibraryGeneratorSchema as JsLibraryGeneratorSchema } from '@nx/js/src/utils/schema';
+import type { LibraryGeneratorOptions, NormalizedOptions } from '../schema';
+export declare function normalizeOptions(tree: Tree, options: LibraryGeneratorOptions): Promise<NormalizedOptions>;
+export declare function toJsLibraryGeneratorOptions(options: LibraryGeneratorOptions): JsLibraryGeneratorSchema;

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

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toJsLibraryGeneratorOptions = exports.normalizeOptions = 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 get_npm_scope_1 = require("@nx/js/src/utils/package-json/get-npm-scope");
+const eslint_1 = require("@nx/eslint");
+async function normalizeOptions(tree, options) {
+    const { projectName, names: projectNames, projectRoot, importPath, } = await (0, project_name_and_root_utils_1.determineProjectNameAndRootOptions)(tree, {
+        name: options.name,
+        projectType: 'library',
+        directory: options.directory,
+        importPath: options.importPath,
+        projectNameAndRootFormat: options.projectNameAndRootFormat,
+        callingGenerator: '@nx/nest:library',
+    });
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const addPlugin = process.env.NX_ADD_PLUGINS !== 'false' &&
+        nxJson.useInferencePlugins !== false;
+    options.addPlugin ??= addPlugin;
+    const fileName = options.simpleName
+        ? projectNames.projectSimpleName
+        : projectNames.projectFileName;
+    const parsedTags = options.tags
+        ? options.tags.split(',').map((s) => s.trim())
+        : [];
+    const normalized = {
+        ...options,
+        strict: options.strict ?? true,
+        controller: options.controller ?? false,
+        fileName,
+        global: options.global ?? false,
+        linter: options.linter ?? eslint_1.Linter.EsLint,
+        parsedTags,
+        prefix: (0, get_npm_scope_1.getNpmScope)(tree), // we could also allow customizing this
+        projectName,
+        projectRoot,
+        importPath,
+        service: options.service ?? false,
+        target: options.target ?? 'es6',
+        testEnvironment: options.testEnvironment ?? 'node',
+        unitTestRunner: options.unitTestRunner ?? 'jest',
+    };
+    return normalized;
+}
+exports.normalizeOptions = normalizeOptions;
+function toJsLibraryGeneratorOptions(options) {
+    return {
+        name: options.name,
+        bundler: options?.buildable ? 'tsc' : 'none',
+        directory: options.directory,
+        importPath: options.importPath,
+        linter: options.linter,
+        publishable: options.publishable,
+        skipFormat: true,
+        skipTsConfig: options.skipTsConfig,
+        skipPackageJson: options.skipPackageJson,
+        strict: options.strict,
+        tags: options.tags,
+        testEnvironment: options.testEnvironment,
+        unitTestRunner: options.unitTestRunner,
+        config: options.standaloneConfig ? 'project' : 'workspace',
+        setParserOptionsProject: options.setParserOptionsProject,
+        projectNameAndRootFormat: options.projectNameAndRootFormat,
+        addPlugin: options.addPlugin,
+    };
+}
+exports.toJsLibraryGeneratorOptions = toJsLibraryGeneratorOptions;

package/src/generators/library/lib/update-tsconfig.d.ts

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

package/src/generators/library/lib/update-tsconfig.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateTsConfig = void 0;
+const devkit_1 = require("@nx/devkit");
+function updateTsConfig(tree, options) {
+    const project = (0, devkit_1.readProjectConfiguration)(tree, options.projectName);
+    return (0, devkit_1.updateJson)(tree, `${project.root}/tsconfig.lib.json`, (json) => {
+        json.compilerOptions.target = options.target;
+        if (options.strict) {
+            json.compilerOptions = {
+                ...json.compilerOptions,
+                strictNullChecks: true,
+                noImplicitAny: true,
+                strictBindCallApply: true,
+                forceConsistentCasingInFileNames: true,
+                noFallthroughCasesInSwitch: true,
+            };
+        }
+        return json;
+    });
+}
+exports.updateTsConfig = updateTsConfig;

package/src/generators/library/library.d.ts

@@ -0,0 +1,5 @@
+import type { GeneratorCallback, Tree } from '@nx/devkit';
+import type { LibraryGeneratorOptions } from './schema';
+export declare function libraryGenerator(tree: Tree, rawOptions: LibraryGeneratorOptions): Promise<GeneratorCallback>;
+export declare function libraryGeneratorInternal(tree: Tree, rawOptions: LibraryGeneratorOptions): Promise<GeneratorCallback>;
+export default libraryGenerator;