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

package/src/executors/verdaccio/verdaccio.impl.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verdaccioExecutor = void 0;
+const devkit_1 = require("@nx/devkit");
+const fs_extra_1 = require("fs-extra");
+const child_process_1 = require("child_process");
+const detectPort = require("detect-port");
+const path_1 = require("path");
+const semver_1 = require("semver");
+let childProcess;
+/**
+ * - set npm and yarn to use local registry
+ * - start verdaccio
+ * - stop local registry when done
+ */
+async function verdaccioExecutor(options, context) {
+    try {
+        require.resolve('verdaccio');
+    }
+    catch (e) {
+        throw new Error('Verdaccio is not installed. Please run `npm install verdaccio` or `yarn add verdaccio`');
+    }
+    if (options.storage) {
+        options.storage = (0, path_1.resolve)(context.root, options.storage);
+        if (options.clear && (0, fs_extra_1.existsSync)(options.storage)) {
+            (0, fs_extra_1.rmSync)(options.storage, { recursive: true, force: true });
+            console.log(`Cleared local registry storage folder ${options.storage}`);
+        }
+    }
+    const port = await detectPort(options.port);
+    if (port !== options.port) {
+        devkit_1.logger.info(`Port ${options.port} was occupied. Using port ${port}.`);
+        options.port = port;
+    }
+    const cleanupFunctions = options.location === 'none' ? [] : [setupNpm(options), setupYarn(options)];
+    const processExitListener = (signal) => {
+        if (childProcess) {
+            childProcess.kill(signal);
+        }
+        for (const fn of cleanupFunctions) {
+            fn();
+        }
+    };
+    process.on('exit', processExitListener);
+    process.on('SIGTERM', processExitListener);
+    process.on('SIGINT', processExitListener);
+    process.on('SIGHUP', processExitListener);
+    try {
+        await startVerdaccio(options, context.root);
+    }
+    catch (e) {
+        devkit_1.logger.error('Failed to start verdaccio: ' + e?.toString());
+        return {
+            success: false,
+            port: options.port,
+        };
+    }
+    return {
+        success: true,
+        port: options.port,
+    };
+}
+exports.verdaccioExecutor = verdaccioExecutor;
+/**
+ * Fork the verdaccio process: https://verdaccio.org/docs/verdaccio-programmatically/#using-fork-from-child_process-module
+ */
+function startVerdaccio(options, workspaceRoot) {
+    return new Promise((resolve, reject) => {
+        childProcess = (0, child_process_1.fork)(require.resolve('verdaccio/bin/verdaccio'), createVerdaccioOptions(options, workspaceRoot), {
+            env: {
+                ...process.env,
+                VERDACCIO_HANDLE_KILL_SIGNALS: 'true',
+                ...(options.storage
+                    ? { VERDACCIO_STORAGE_PATH: options.storage }
+                    : {}),
+            },
+            stdio: 'inherit',
+        });
+        childProcess.on('error', (err) => {
+            reject(err);
+        });
+        childProcess.on('disconnect', (err) => {
+            reject(err);
+        });
+        childProcess.on('exit', (code) => {
+            if (code === 0) {
+                resolve(code);
+            }
+            else {
+                reject(code);
+            }
+        });
+    });
+}
+function createVerdaccioOptions(options, workspaceRoot) {
+    const verdaccioArgs = [];
+    if (options.port) {
+        verdaccioArgs.push('--listen', options.port.toString());
+    }
+    if (options.config) {
+        verdaccioArgs.push('--config', (0, path_1.join)(workspaceRoot, options.config));
+    }
+    return verdaccioArgs;
+}
+function setupNpm(options) {
+    try {
+        (0, child_process_1.execSync)('npm --version');
+    }
+    catch (e) {
+        return () => { };
+    }
+    let npmRegistryPath;
+    try {
+        npmRegistryPath = (0, child_process_1.execSync)(`npm config get registry --location ${options.location}`)
+            ?.toString()
+            ?.trim()
+            ?.replace('\u001b[2K\u001b[1G', ''); // strip out ansi codes
+        (0, child_process_1.execSync)(`npm config set registry http://localhost:${options.port}/ --location ${options.location}`);
+        (0, child_process_1.execSync)(`npm config set //localhost:${options.port}/:_authToken="secretVerdaccioToken" --location ${options.location}`);
+        devkit_1.logger.info(`Set npm registry to http://localhost:${options.port}/`);
+    }
+    catch (e) {
+        throw new Error(`Failed to set npm registry to http://localhost:${options.port}/: ${e.message}`);
+    }
+    return () => {
+        try {
+            const currentNpmRegistryPath = (0, child_process_1.execSync)(`npm config get registry --location ${options.location}`)
+                ?.toString()
+                ?.trim()
+                ?.replace('\u001b[2K\u001b[1G', ''); // strip out ansi codes
+            if (npmRegistryPath && currentNpmRegistryPath.includes('localhost')) {
+                (0, child_process_1.execSync)(`npm config set registry ${npmRegistryPath} --location ${options.location}`);
+                devkit_1.logger.info(`Reset npm registry to ${npmRegistryPath}`);
+            }
+            else {
+                (0, child_process_1.execSync)(`npm config delete registry --location ${options.location}`);
+                devkit_1.logger.info('Cleared custom npm registry');
+            }
+            (0, child_process_1.execSync)(`npm config delete //localhost:${options.port}/:_authToken  --location ${options.location}`);
+        }
+        catch (e) {
+            throw new Error(`Failed to reset npm registry: ${e.message}`);
+        }
+    };
+}
+function getYarnUnsafeHttpWhitelist(isYarnV1) {
+    return !isYarnV1
+        ? new Set(JSON.parse((0, child_process_1.execSync)(`yarn config get unsafeHttpWhitelist --json`).toString()))
+        : null;
+}
+function setYarnUnsafeHttpWhitelist(currentWhitelist, options) {
+    if (currentWhitelist.size > 0) {
+        (0, child_process_1.execSync)(`yarn config set unsafeHttpWhitelist --json '${JSON.stringify(Array.from(currentWhitelist))}'` + (options.location === 'user' ? ' --home' : ''));
+    }
+    else {
+        (0, child_process_1.execSync)(`yarn config unset unsafeHttpWhitelist` +
+            (options.location === 'user' ? ' --home' : ''));
+    }
+}
+function setupYarn(options) {
+    let isYarnV1;
+    try {
+        isYarnV1 = (0, semver_1.major)((0, child_process_1.execSync)('yarn --version').toString().trim()) === 1;
+    }
+    catch {
+        // This would fail if yarn is not installed which is okay
+        return () => { };
+    }
+    try {
+        const registryConfigName = isYarnV1 ? 'registry' : 'npmRegistryServer';
+        const yarnRegistryPath = (0, child_process_1.execSync)(`yarn config get ${registryConfigName}`)
+            ?.toString()
+            ?.trim()
+            ?.replace('\u001b[2K\u001b[1G', ''); // strip out ansi codes
+        (0, child_process_1.execSync)(`yarn config set ${registryConfigName} http://localhost:${options.port}/` +
+            (options.location === 'user' ? ' --home' : ''));
+        devkit_1.logger.info(`Set yarn registry to http://localhost:${options.port}/`);
+        const currentWhitelist = getYarnUnsafeHttpWhitelist(isYarnV1);
+        let whitelistedLocalhost = false;
+        if (!isYarnV1 && !currentWhitelist.has('localhost')) {
+            whitelistedLocalhost = true;
+            currentWhitelist.add('localhost');
+            setYarnUnsafeHttpWhitelist(currentWhitelist, options);
+            devkit_1.logger.info(`Whitelisted http://localhost:${options.port}/ as an unsafe http server`);
+        }
+        return () => {
+            try {
+                const currentYarnRegistryPath = (0, child_process_1.execSync)(`yarn config get ${registryConfigName}`)
+                    ?.toString()
+                    ?.trim()
+                    ?.replace('\u001b[2K\u001b[1G', ''); // strip out ansi codes
+                if (yarnRegistryPath && currentYarnRegistryPath.includes('localhost')) {
+                    (0, child_process_1.execSync)(`yarn config set ${registryConfigName} ${yarnRegistryPath}` +
+                        (options.location === 'user' ? ' --home' : ''));
+                    devkit_1.logger.info(`Reset yarn ${registryConfigName} to ${yarnRegistryPath}`);
+                }
+                else {
+                    (0, child_process_1.execSync)(`yarn config ${isYarnV1 ? 'delete' : 'unset'} ${registryConfigName}` +
+                        (options.location === 'user' ? ' --home' : ''));
+                    devkit_1.logger.info(`Cleared custom yarn ${registryConfigName}`);
+                }
+                if (whitelistedLocalhost) {
+                    const currentWhitelist = getYarnUnsafeHttpWhitelist(isYarnV1);
+                    if (currentWhitelist.has('localhost')) {
+                        currentWhitelist.delete('localhost');
+                        setYarnUnsafeHttpWhitelist(currentWhitelist, options);
+                        devkit_1.logger.info(`Removed http://localhost:${options.port}/ as an unsafe http server`);
+                    }
+                }
+            }
+            catch (e) {
+                throw new Error(`Failed to reset yarn registry: ${e.message}`);
+            }
+        };
+    }
+    catch (e) {
+        throw new Error(`Failed to set yarn registry to http://localhost:${options.port}/: ${e.message}`);
+    }
+}
+exports.default = verdaccioExecutor;

package/src/generators/convert-to-swc/convert-to-swc.d.ts

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

package/src/generators/convert-to-swc/convert-to-swc.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToSwcGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const add_swc_config_1 = require("../../utils/swc/add-swc-config");
+const add_swc_dependencies_1 = require("../../utils/swc/add-swc-dependencies");
+const versions_1 = require("../../utils/versions");
+async function convertToSwcGenerator(tree, schema) {
+    const options = normalizeOptions(schema);
+    const projectConfiguration = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    updateProjectBuildTargets(tree, projectConfiguration, options.project, options.targets);
+    return checkSwcDependencies(tree, projectConfiguration);
+}
+exports.convertToSwcGenerator = convertToSwcGenerator;
+function normalizeOptions(schema) {
+    const options = { ...schema };
+    if (!options.targets) {
+        options.targets = ['build'];
+    }
+    return options;
+}
+function updateProjectBuildTargets(tree, projectConfiguration, projectName, projectTargets) {
+    for (const target of projectTargets) {
+        const targetConfiguration = projectConfiguration.targets[target];
+        if (!targetConfiguration ||
+            (targetConfiguration.executor !== '@nx/js:tsc' &&
+                targetConfiguration.executor !== '@nrwl/js:tsc'))
+            continue;
+        targetConfiguration.executor = '@nx/js:swc';
+    }
+    (0, devkit_1.updateProjectConfiguration)(tree, projectName, projectConfiguration);
+}
+function checkSwcDependencies(tree, projectConfiguration) {
+    const isSwcrcPresent = tree.exists((0, path_1.join)(projectConfiguration.root, '.swcrc'));
+    const packageJson = (0, devkit_1.readJson)(tree, 'package.json');
+    const projectPackageJsonPath = (0, path_1.join)(projectConfiguration.root, 'package.json');
+    const projectPackageJson = (0, devkit_1.readJson)(tree, projectPackageJsonPath);
+    const hasSwcDependency = packageJson.dependencies && packageJson.dependencies['@swc/core'];
+    const hasSwcHelpers = projectPackageJson.dependencies &&
+        projectPackageJson.dependencies['@swc/helpers'];
+    if (isSwcrcPresent && hasSwcDependency && hasSwcHelpers)
+        return;
+    if (!isSwcrcPresent) {
+        (0, add_swc_config_1.addSwcConfig)(tree, projectConfiguration.root);
+    }
+    if (!hasSwcDependency) {
+        (0, add_swc_dependencies_1.addSwcDependencies)(tree);
+    }
+    if (!hasSwcHelpers) {
+        (0, devkit_1.addDependenciesToPackageJson)(tree, { '@swc/helpers': versions_1.swcHelpersVersion }, {}, projectPackageJsonPath);
+    }
+    return () => {
+        if (!hasSwcDependency) {
+            (0, devkit_1.installPackagesTask)(tree);
+        }
+    };
+}
+exports.default = convertToSwcGenerator;

package/src/generators/convert-to-swc/schema.d.ts

@@ -0,0 +1,4 @@
+export interface ConvertToSwcGeneratorSchema {
+  project: string;
+  targets?: string[];
+}

package/src/generators/convert-to-swc/schema.json

@@ -0,0 +1,36 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxTypescriptLibrary",
+  "cli": "nx",
+  "title": "Convert a TSC library to SWC",
+  "description": "Convert a TSC library to SWC.",
+  "type": "object",
+  "examples": [
+    {
+      "command": "nx g swc mylib",
+      "description": "Convert `libs/myapp/mylib` to SWC."
+    }
+  ],
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "Library name.",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "What name would you like to use for the library?",
+      "pattern": "^[a-zA-Z].*$"
+    },
+    "targets": {
+      "type": "array",
+      "description": "List of targets to convert.",
+      "items": {
+        "type": "string",
+        "description": "Target to convert."
+      },
+      "default": ["build"]
+    }
+  },
+  "required": ["project"]
+}

package/src/generators/init/files/__fileName__

@@ -0,0 +1,20 @@
+{
+  "compileOnSave": false,
+  "compilerOptions": {
+    "rootDir": ".",
+    "sourceMap": true,
+    "declaration": false,
+    "moduleResolution": "node",
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "importHelpers": true,
+    "target": "es2015",
+    "module": "esnext",
+    "lib": ["es2020", "dom"],
+    "skipLibCheck": true,
+    "skipDefaultLibCheck": true,
+    "baseUrl": ".",
+    "paths": {}
+  },
+  "exclude": ["node_modules", "tmp"]
+}

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

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

package/src/generators/init/init.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+const semver_1 = require("@nx/devkit/src/utils/semver");
+const package_json_1 = require("nx/src/utils/package-json");
+const semver_2 = require("semver");
+const ts_config_1 = require("../../utils/typescript/ts-config");
+const versions_1 = require("../../utils/versions");
+const path_1 = require("path");
+async function getInstalledTypescriptVersion(tree) {
+    const rootPackageJson = (0, devkit_1.readJson)(tree, 'package.json');
+    const tsVersionInRootPackageJson = rootPackageJson.devDependencies?.['typescript'] ??
+        rootPackageJson.dependencies?.['typescript'];
+    if (!tsVersionInRootPackageJson) {
+        return null;
+    }
+    if ((0, semver_2.valid)(tsVersionInRootPackageJson)) {
+        // it's a pinned version, return it
+        return tsVersionInRootPackageJson;
+    }
+    // it's a version range, check whether the installed version matches it
+    try {
+        const tsPackageJson = (0, package_json_1.readModulePackageJson)('typescript').packageJson;
+        const installedTsVersion = tsPackageJson.devDependencies?.['typescript'] ??
+            tsPackageJson.dependencies?.['typescript'];
+        // the installed version matches the package.json version range
+        if (installedTsVersion &&
+            (0, semver_2.satisfies)(installedTsVersion, tsVersionInRootPackageJson)) {
+            return installedTsVersion;
+        }
+    }
+    finally {
+        return (0, semver_1.checkAndCleanWithSemver)('typescript', tsVersionInRootPackageJson);
+    }
+}
+async function initGenerator(tree, schema) {
+    const tasks = [];
+    // add tsconfig.base.json
+    if (!(0, ts_config_1.getRootTsConfigFileName)(tree)) {
+        (0, devkit_1.generateFiles)(tree, (0, path_1.join)(__dirname, './files'), '.', {
+            fileName: schema.tsConfigName ?? 'tsconfig.base.json',
+        });
+    }
+    const devDependencies = {
+        '@nx/js': versions_1.nxVersion,
+        prettier: versions_1.prettierVersion,
+        // When loading .ts config files (e.g. webpack.config.ts, jest.config.ts, etc.)
+        // we prefer to use SWC, and fallback to ts-node for workspaces that don't use SWC.
+        '@swc-node/register': versions_1.swcNodeVersion,
+        '@swc/core': versions_1.swcCoreVersion,
+        '@swc/helpers': versions_1.swcHelpersVersion,
+    };
+    if (!schema.js && !schema.keepExistingVersions) {
+        const installedTsVersion = await getInstalledTypescriptVersion(tree);
+        if (!installedTsVersion ||
+            !(0, semver_2.satisfies)(installedTsVersion, versions_1.supportedTypescriptVersions, {
+                includePrerelease: true,
+            })) {
+            devDependencies['typescript'] = versions_1.typescriptVersion;
+        }
+    }
+    // https://prettier.io/docs/en/configuration.html
+    const prettierrcNameOptions = [
+        '.prettierrc',
+        '.prettierrc.json',
+        '.prettierrc.yml',
+        '.prettierrc.yaml',
+        '.prettierrc.json5',
+        '.prettierrc.js',
+        '.prettierrc.cjs',
+        'prettier.config.js',
+        'prettier.config.cjs',
+        '.prettierrc.toml',
+    ];
+    if (prettierrcNameOptions.every((name) => !tree.exists(name))) {
+        (0, devkit_1.writeJson)(tree, '.prettierrc', {
+            singleQuote: true,
+        });
+    }
+    if (!tree.exists(`.prettierignore`)) {
+        tree.write('.prettierignore', (0, devkit_1.stripIndents) `
+        # Add files here to ignore them from prettier formatting
+        /dist
+        /coverage
+        /.nx/cache
+      `);
+    }
+    if (tree.exists('.vscode/extensions.json')) {
+        (0, devkit_1.updateJson)(tree, '.vscode/extensions.json', (json) => {
+            json.recommendations ??= [];
+            const extension = 'esbenp.prettier-vscode';
+            if (!json.recommendations.includes(extension)) {
+                json.recommendations.push(extension);
+            }
+            return json;
+        });
+    }
+    const installTask = !schema.skipPackageJson
+        ? (0, devkit_1.addDependenciesToPackageJson)(tree, {}, devDependencies, undefined, schema.keepExistingVersions)
+        : () => { };
+    tasks.push(installTask);
+    (0, devkit_1.ensurePackage)('prettier', versions_1.prettierVersion);
+    if (!schema.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return async () => {
+        for (const task of tasks) {
+            await task();
+        }
+    };
+}
+exports.initGenerator = initGenerator;
+exports.default = initGenerator;

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

@@ -0,0 +1,7 @@
+export interface InitSchema {
+  js?: boolean;
+  skipFormat?: boolean;
+  skipPackageJson?: boolean;
+  keepExistingVersions?: boolean;
+  tsConfigName?: string;
+}

package/src/generators/init/schema.json

@@ -0,0 +1,36 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxTypescriptInit",
+  "cli": "nx",
+  "title": "Init nx/js",
+  "description": "Init generator placeholder for nx/js.",
+  "properties": {
+    "js": {
+      "type": "boolean",
+      "default": false,
+      "description": "Use JavaScript instead of TypeScript"
+    },
+    "skipFormat": {
+      "type": "boolean",
+      "aliases": ["skip-format"],
+      "description": "Skip formatting files.",
+      "x-priority": "internal"
+    },
+    "skipPackageJson": {
+      "type": "boolean",
+      "description": "Skip adding package.json dependencies",
+      "x-priority": "internal"
+    },
+    "keepExistingVersions": {
+      "type": "boolean",
+      "x-priority": "internal",
+      "description": "Keep existing dependencies versions",
+      "default": false
+    },
+    "tsConfigName": {
+      "type": "string",
+      "description": "Customize the generated tsconfig file name.",
+      "x-priority": "internal"
+    }
+  }
+}

package/src/generators/library/files/jest-config/jest.config.__ext__

@@ -0,0 +1,30 @@
+/* eslint-disable */
+<% if(js) {%>const { readFileSync } = require('fs')<% } else { %>import { readFileSync } from 'fs';<% } %>
+
+// Reading the SWC compilation config and remove the "exclude"
+// for the test files to be compiled by SWC
+const { exclude: _, ...swcJestConfig } = JSON.parse(
+  readFileSync(`${__dirname}/.swcrc`, 'utf-8')
+);
+
+// disable .swcrc look-up by SWC core because we're passing in swcJestConfig ourselves.
+// If we do not disable this, SWC Core will read .swcrc and won't transform our test files due to "exclude"
+if (swcJestConfig.swcrc === undefined) {
+    swcJestConfig.swcrc = false;
+}
+
+// Uncomment if using global setup/teardown files being transformed via swc
+// https://nx.dev/packages/jest/documents/overview#global-setup/teardown-with-nx-libraries
+// jest needs EsModule Interop to find the default exported setup/teardown functions
+// swcJestConfig.module.noInterop = false;
+
+<% if(js) {%>module.exports =<% } else { %>export default<% } %> {
+  displayName: '<%= project %>',
+  preset: '<%= offsetFromRoot %>jest.preset.js',
+  transform: {
+    '^.+\\.[tj]s$': ['@swc/jest', swcJestConfig],
+  },
+  moduleFileExtensions: ['ts', 'js', 'html'],
+  testEnvironment: '<%= testEnvironment %>',
+  coverageDirectory: '<%= offsetFromRoot %>coverage/<%= projectRoot %>'
+};

package/src/generators/library/files/lib/src/index.ts__tmpl__

@@ -0,0 +1 @@
+export * from './lib/<%= fileName %>';

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

@@ -0,0 +1,7 @@
+import { <%= propertyName %> } from './<%= fileName %>';
+
+describe('<%= propertyName %>', () => {
+    it('should work', () => {
+        expect(<%= propertyName %>()).toEqual('<%= name %>');
+    })
+})

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

@@ -0,0 +1,3 @@
+export function <%= propertyName %>(): string {
+    return '<%= name %>';
+}

package/src/generators/library/files/lib/tsconfig.lib.json__tmpl__

@@ -0,0 +1,14 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "<%= offsetFromRoot %>dist/out-tsc",
+    "declaration": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"<% if (js) { %>, "src/**/*.js"<% } %>],
+  "exclude": [
+    <% if (hasUnitTestRunner && unitTestRunner === 'jest') { %>"jest.config.ts", 
+    <% } else if (hasUnitTestRunner) { %>"vite.config.ts", 
+    <% } %>"src/**/*.spec.ts", "src/**/*.test.ts"<% if (js) { %>, "src/**/*.spec.js", "src/**/*.test.js"<% } %>
+  ]
+}

package/src/generators/library/files/readme/README.md

@@ -0,0 +1,19 @@
+# <%= name %>
+
+This library was generated with [Nx](https://nx.dev).
+
+<% if (buildable) { %>
+
+## Building
+
+Run `<%= cliCommand %> build <%= name %>` to build the library.
+
+<% } %>
+
+<% if (hasUnitTestRunner) { %>
+
+## Running unit tests
+
+Run `<%= cliCommand %> test <%= name %>` to execute the unit tests via <% if(unitTestRunner === 'jest') { %>[Jest](https://jestjs.io)<% } else { %>[Vitest](https://vitest.dev/)<% } %>.
+
+<% } %>

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

@@ -0,0 +1,16 @@
+import { GeneratorCallback, Tree } from '@nx/devkit';
+import { type ProjectNameAndRootOptions } from '@nx/devkit/src/generators/project-name-and-root-utils';
+import { LibraryGeneratorSchema } from '../../utils/schema';
+export declare function libraryGenerator(tree: Tree, schema: LibraryGeneratorSchema): Promise<GeneratorCallback>;
+export declare function libraryGeneratorInternal(tree: Tree, schema: LibraryGeneratorSchema): Promise<GeneratorCallback>;
+export interface NormalizedSchema extends LibraryGeneratorSchema {
+    name: string;
+    projectNames: ProjectNameAndRootOptions['names'];
+    fileName: string;
+    projectRoot: string;
+    parsedTags: string[];
+    importPath?: string;
+}
+export type AddLintOptions = Pick<NormalizedSchema, 'name' | 'linter' | 'projectRoot' | 'unitTestRunner' | 'js' | 'setParserOptionsProject' | 'rootProject' | 'bundler' | 'addPlugin'>;
+export declare function addLint(tree: Tree, options: AddLintOptions): Promise<GeneratorCallback>;
+export default libraryGenerator;