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

package/src/generators/library/library.js

@@ -0,0 +1,751 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addLint = exports.libraryGeneratorInternal = exports.libraryGenerator = 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 add_build_target_defaults_1 = require("@nx/devkit/src/generators/add-build-target-defaults");
+const log_show_project_command_1 = require("@nx/devkit/src/utils/log-show-project-command");
+const find_matching_projects_1 = require("nx/src/utils/find-matching-projects");
+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 create_ts_config_1 = require("../../utils/typescript/create-ts-config");
+const ts_config_1 = require("../../utils/typescript/ts-config");
+const versions_1 = require("../../utils/versions");
+const init_1 = require("../init/init");
+const generator_1 = require("../setup-verdaccio/generator");
+const defaultOutputDirectory = 'dist';
+async function libraryGenerator(tree, schema) {
+    return await libraryGeneratorInternal(tree, {
+        addPlugin: false,
+        // provide a default projectNameAndRootFormat to avoid breaking changes
+        // to external generators invoking this one
+        projectNameAndRootFormat: 'derived',
+        ...schema,
+    });
+}
+exports.libraryGenerator = libraryGenerator;
+async function libraryGeneratorInternal(tree, schema) {
+    const tasks = [];
+    tasks.push(await (0, init_1.default)(tree, {
+        ...schema,
+        skipFormat: true,
+        tsConfigName: schema.rootProject ? 'tsconfig.json' : 'tsconfig.base.json',
+    }));
+    const options = await normalizeOptions(tree, schema);
+    createFiles(tree, options);
+    await addProject(tree, options);
+    if (!options.skipPackageJson) {
+        tasks.push(addProjectDependencies(tree, options));
+    }
+    if (options.publishable) {
+        tasks.push(await (0, generator_1.default)(tree, { ...options, skipFormat: true }));
+    }
+    if (options.bundler === 'vite') {
+        const { viteConfigurationGenerator, createOrEditViteConfig } = (0, devkit_1.ensurePackage)('@nx/vite', versions_1.nxVersion);
+        const viteTask = await viteConfigurationGenerator(tree, {
+            project: options.name,
+            newProject: true,
+            uiFramework: 'none',
+            includeVitest: options.unitTestRunner === 'vitest',
+            includeLib: true,
+            skipFormat: true,
+            testEnvironment: options.testEnvironment,
+            addPlugin: options.addPlugin,
+        });
+        tasks.push(viteTask);
+        createOrEditViteConfig(tree, {
+            project: options.name,
+            includeLib: true,
+            includeVitest: options.unitTestRunner === 'vitest',
+            testEnvironment: options.testEnvironment,
+        }, false);
+    }
+    if (options.linter !== 'none') {
+        const lintCallback = await addLint(tree, options);
+        tasks.push(lintCallback);
+    }
+    if (options.unitTestRunner === 'jest') {
+        const jestCallback = await addJest(tree, options);
+        tasks.push(jestCallback);
+        if (options.bundler === 'swc' || options.bundler === 'rollup') {
+            replaceJestConfig(tree, options);
+        }
+    }
+    else if (options.unitTestRunner === 'vitest' &&
+        options.bundler !== 'vite' // Test would have been set up already
+    ) {
+        const { vitestGenerator, createOrEditViteConfig } = (0, devkit_1.ensurePackage)('@nx/vite', versions_1.nxVersion);
+        const vitestTask = await vitestGenerator(tree, {
+            project: options.name,
+            uiFramework: 'none',
+            coverageProvider: 'v8',
+            skipFormat: true,
+            testEnvironment: options.testEnvironment,
+        });
+        tasks.push(vitestTask);
+        createOrEditViteConfig(tree, {
+            project: options.name,
+            includeLib: false,
+            includeVitest: true,
+            testEnvironment: options.testEnvironment,
+        }, true);
+    }
+    if (!schema.skipTsConfig) {
+        (0, ts_config_1.addTsConfigPath)(tree, options.importPath, [
+            (0, devkit_1.joinPathFragments)(options.projectRoot, './src', 'index.' + (options.js ? 'js' : 'ts')),
+        ]);
+    }
+    if (options.bundler !== 'none') {
+        addBundlerDependencies(tree, options);
+    }
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    if (options.publishable) {
+        tasks.push(() => {
+            logNxReleaseDocsInfo();
+        });
+    }
+    tasks.push(() => {
+        (0, log_show_project_command_1.logShowProjectCommand)(options.name);
+    });
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+exports.libraryGeneratorInternal = libraryGeneratorInternal;
+async function addProject(tree, options) {
+    const projectConfiguration = {
+        root: options.projectRoot,
+        sourceRoot: (0, devkit_1.joinPathFragments)(options.projectRoot, 'src'),
+        projectType: 'library',
+        targets: {},
+        tags: options.parsedTags,
+    };
+    if (options.bundler &&
+        options.bundler !== 'none' &&
+        options.config !== 'npm-scripts') {
+        const outputPath = getOutputPath(options);
+        const executor = getBuildExecutor(options.bundler);
+        (0, add_build_target_defaults_1.addBuildTargetDefaults)(tree, executor);
+        projectConfiguration.targets.build = {
+            executor,
+            outputs: ['{options.outputPath}'],
+            options: {
+                outputPath,
+                main: `${options.projectRoot}/src/index` + (options.js ? '.js' : '.ts'),
+                tsConfig: `${options.projectRoot}/tsconfig.lib.json`,
+                assets: [],
+            },
+        };
+        if (options.bundler === 'esbuild') {
+            projectConfiguration.targets.build.options.generatePackageJson = true;
+            projectConfiguration.targets.build.options.format = ['cjs'];
+        }
+        if (options.bundler === 'rollup') {
+            projectConfiguration.targets.build.options.project = `${options.projectRoot}/package.json`;
+            projectConfiguration.targets.build.options.compiler = 'swc';
+            projectConfiguration.targets.build.options.format = ['cjs', 'esm'];
+        }
+        if (options.bundler === 'swc' && options.skipTypeCheck) {
+            projectConfiguration.targets.build.options.skipTypeCheck = true;
+        }
+        if (!options.minimal &&
+            // TODO(jack): assets for rollup have validation that we need to fix (assets must be under <project-root>/src)
+            options.bundler !== 'rollup') {
+            projectConfiguration.targets.build.options.assets ??= [];
+            projectConfiguration.targets.build.options.assets.push((0, devkit_1.joinPathFragments)(options.projectRoot, '*.md'));
+        }
+        if (options.publishable) {
+            const packageRoot = (0, path_1.join)(defaultOutputDirectory, '{projectRoot}');
+            projectConfiguration.targets ??= {};
+            projectConfiguration.targets['nx-release-publish'] = {
+                options: {
+                    packageRoot,
+                },
+            };
+            projectConfiguration.release = {
+                version: {
+                    generatorOptions: {
+                        packageRoot,
+                        // using git tags to determine the current version is required here because
+                        // the version in the package root is overridden with every build
+                        currentVersionResolver: 'git-tag',
+                    },
+                },
+            };
+            await addProjectToNxReleaseConfig(tree, options, projectConfiguration);
+        }
+    }
+    if (options.config === 'workspace' || options.config === 'project') {
+        (0, devkit_1.addProjectConfiguration)(tree, options.name, projectConfiguration);
+    }
+    else {
+        (0, devkit_1.addProjectConfiguration)(tree, options.name, {
+            root: projectConfiguration.root,
+            tags: projectConfiguration.tags,
+            targets: {},
+        }, true);
+    }
+}
+async function addLint(tree, options) {
+    const { lintProjectGenerator } = (0, devkit_1.ensurePackage)('@nx/eslint', versions_1.nxVersion);
+    const projectConfiguration = (0, devkit_1.readProjectConfiguration)(tree, options.name);
+    const task = await lintProjectGenerator(tree, {
+        project: options.name,
+        linter: options.linter,
+        skipFormat: true,
+        tsConfigPaths: [
+            (0, devkit_1.joinPathFragments)(options.projectRoot, 'tsconfig.lib.json'),
+        ],
+        unitTestRunner: options.unitTestRunner,
+        setParserOptionsProject: options.setParserOptionsProject,
+        rootProject: options.rootProject,
+        addPlugin: options.addPlugin,
+    });
+    const { addOverrideToLintConfig, lintConfigHasOverride, isEslintConfigSupported, updateOverrideInLintConfig,
+    // nx-ignore-next-line
+     } = require('@nx/eslint/src/generators/utils/eslint-file');
+    // if config is not supported, we don't need to do anything
+    if (!isEslintConfigSupported(tree)) {
+        return task;
+    }
+    // Also update the root ESLint config. The lintProjectGenerator will not generate it for root projects.
+    // But we need to set the package.json checks.
+    if (options.rootProject) {
+        addOverrideToLintConfig(tree, '', {
+            files: ['*.json'],
+            parser: 'jsonc-eslint-parser',
+            rules: {
+                '@nx/dependency-checks': 'error',
+            },
+        });
+    }
+    // If project lints package.json with @nx/dependency-checks, then add ignore files for
+    // build configuration files such as vite.config.ts. These config files need to be
+    // ignored, otherwise we will errors on missing dependencies that are for dev only.
+    if (lintConfigHasOverride(tree, projectConfiguration.root, (o) => Array.isArray(o.files)
+        ? o.files.some((f) => f.match(/\.json$/))
+        : !!o.files?.match(/\.json$/), true)) {
+        updateOverrideInLintConfig(tree, projectConfiguration.root, (o) => o.rules?.['@nx/dependency-checks'], (o) => {
+            const value = o.rules['@nx/dependency-checks'];
+            let ruleSeverity;
+            let ruleOptions;
+            if (Array.isArray(value)) {
+                ruleSeverity = value[0];
+                ruleOptions = value[1];
+            }
+            else {
+                ruleSeverity = value;
+                ruleOptions = {};
+            }
+            if (options.bundler === 'vite' || options.unitTestRunner === 'vitest') {
+                ruleOptions.ignoredFiles = [
+                    '{projectRoot}/vite.config.{js,ts,mjs,mts}',
+                ];
+                o.rules['@nx/dependency-checks'] = [ruleSeverity, ruleOptions];
+            }
+            else if (options.bundler === 'rollup') {
+                ruleOptions.ignoredFiles = [
+                    '{projectRoot}/rollup.config.{js,ts,mjs,mts}',
+                ];
+                o.rules['@nx/dependency-checks'] = [ruleSeverity, ruleOptions];
+            }
+            else if (options.bundler === 'esbuild') {
+                ruleOptions.ignoredFiles = [
+                    '{projectRoot}/esbuild.config.{js,ts,mjs,mts}',
+                ];
+                o.rules['@nx/dependency-checks'] = [ruleSeverity, ruleOptions];
+            }
+            return o;
+        });
+    }
+    return task;
+}
+exports.addLint = addLint;
+function addBundlerDependencies(tree, options) {
+    (0, devkit_1.updateJson)(tree, `${options.projectRoot}/package.json`, (json) => {
+        if (options.bundler === 'tsc') {
+            json.dependencies = {
+                ...json.dependencies,
+                tslib: versions_1.tsLibVersion,
+            };
+        }
+        else if (options.bundler === 'swc') {
+            json.dependencies = {
+                ...json.dependencies,
+                '@swc/helpers': versions_1.swcHelpersVersion,
+            };
+        }
+        return json;
+    });
+}
+function updateTsConfig(tree, options) {
+    (0, devkit_1.updateJson)(tree, (0, path_1.join)(options.projectRoot, 'tsconfig.json'), (json) => {
+        if (options.strict) {
+            json.compilerOptions = {
+                ...json.compilerOptions,
+                forceConsistentCasingInFileNames: true,
+                strict: true,
+                noImplicitOverride: true,
+                noPropertyAccessFromIndexSignature: true,
+                noImplicitReturns: true,
+                noFallthroughCasesInSwitch: true,
+            };
+        }
+        return json;
+    });
+}
+function addBabelRc(tree, options) {
+    const filename = '.babelrc';
+    const babelrc = {
+        presets: [['@nx/js/babel', { useBuiltIns: 'usage' }]],
+    };
+    (0, devkit_1.writeJson)(tree, (0, path_1.join)(options.projectRoot, filename), babelrc);
+}
+function createFiles(tree, options) {
+    const { className, name, propertyName } = (0, devkit_1.names)(options.projectNames.projectFileName);
+    createProjectTsConfigJson(tree, options);
+    (0, devkit_1.generateFiles)(tree, (0, path_1.join)(__dirname, './files/lib'), options.projectRoot, {
+        ...options,
+        dot: '.',
+        className,
+        name,
+        propertyName,
+        js: !!options.js,
+        cliCommand: 'nx',
+        strict: undefined,
+        tmpl: '',
+        offsetFromRoot: (0, devkit_1.offsetFromRoot)(options.projectRoot),
+        buildable: options.bundler && options.bundler !== 'none',
+        hasUnitTestRunner: options.unitTestRunner !== 'none',
+    });
+    if (!options.rootProject) {
+        (0, devkit_1.generateFiles)(tree, (0, path_1.join)(__dirname, './files/readme'), options.projectRoot, {
+            ...options,
+            dot: '.',
+            className,
+            name,
+            propertyName,
+            js: !!options.js,
+            cliCommand: 'nx',
+            strict: undefined,
+            tmpl: '',
+            offsetFromRoot: (0, devkit_1.offsetFromRoot)(options.projectRoot),
+            buildable: options.bundler && options.bundler !== 'none',
+            hasUnitTestRunner: options.unitTestRunner !== 'none',
+        });
+    }
+    if (options.bundler === 'swc' || options.bundler === 'rollup') {
+        (0, add_swc_dependencies_1.addSwcDependencies)(tree);
+        (0, add_swc_config_1.addSwcConfig)(tree, options.projectRoot, options.bundler === 'swc' ? 'commonjs' : 'es6');
+    }
+    else if (options.includeBabelRc) {
+        addBabelRc(tree, options);
+    }
+    if (options.unitTestRunner === 'none') {
+        tree.delete((0, path_1.join)(options.projectRoot, 'src/lib', `${options.fileName}.spec.ts`));
+        tree.delete((0, path_1.join)(options.projectRoot, 'src/app', `${options.fileName}.spec.ts`));
+    }
+    if (options.js) {
+        (0, devkit_1.toJS)(tree);
+    }
+    const packageJsonPath = (0, devkit_1.joinPathFragments)(options.projectRoot, 'package.json');
+    if (tree.exists(packageJsonPath)) {
+        (0, devkit_1.updateJson)(tree, packageJsonPath, (json) => {
+            json.name = options.importPath;
+            json.version = '0.0.1';
+            // If the package is publishable or root/standalone, we should remove the private field.
+            if (json.private && (options.publishable || options.rootProject)) {
+                delete json.private;
+            }
+            if (!options.publishable && !options.rootProject) {
+                json.private = true;
+            }
+            return {
+                ...json,
+                dependencies: {
+                    ...json.dependencies,
+                    ...determineDependencies(options),
+                },
+                ...determineEntryFields(options),
+            };
+        });
+    }
+    else {
+        const packageJson = {
+            name: options.importPath,
+            version: '0.0.1',
+            dependencies: determineDependencies(options),
+            ...determineEntryFields(options),
+        };
+        if (!options.publishable && !options.rootProject) {
+            packageJson.private = true;
+        }
+        (0, devkit_1.writeJson)(tree, packageJsonPath, packageJson);
+    }
+    if (options.config === 'npm-scripts') {
+        (0, devkit_1.updateJson)(tree, packageJsonPath, (json) => {
+            json.scripts = {
+                build: "echo 'implement build'",
+                test: "echo 'implement test'",
+            };
+            return json;
+        });
+    }
+    else if ((!options.bundler || options.bundler === 'none') &&
+        !(options.projectRoot === '.')) {
+        tree.delete(packageJsonPath);
+    }
+    if (options.minimal && !(options.projectRoot === '.')) {
+        tree.delete((0, path_1.join)(options.projectRoot, 'README.md'));
+    }
+    updateTsConfig(tree, options);
+}
+async function addJest(tree, options) {
+    const { configurationGenerator } = (0, devkit_1.ensurePackage)('@nx/jest', versions_1.nxVersion);
+    return await configurationGenerator(tree, {
+        ...options,
+        project: options.name,
+        setupFile: 'none',
+        supportTsx: false,
+        skipSerializers: true,
+        testEnvironment: options.testEnvironment,
+        skipFormat: true,
+        compiler: options.bundler === 'swc' || options.bundler === 'tsc'
+            ? options.bundler
+            : options.bundler === 'rollup'
+                ? 'swc'
+                : undefined,
+    });
+}
+function replaceJestConfig(tree, options) {
+    const filesDir = (0, path_1.join)(__dirname, './files/jest-config');
+    // the existing config has to be deleted otherwise the new config won't overwrite it
+    const existingJestConfig = (0, devkit_1.joinPathFragments)(filesDir, `jest.config.${options.js ? 'js' : 'ts'}`);
+    if (tree.exists(existingJestConfig)) {
+        tree.delete(existingJestConfig);
+    }
+    // replace with JS:SWC specific jest config
+    (0, devkit_1.generateFiles)(tree, filesDir, options.projectRoot, {
+        ext: options.js ? 'js' : 'ts',
+        js: !!options.js,
+        project: options.name,
+        offsetFromRoot: (0, devkit_1.offsetFromRoot)(options.projectRoot),
+        projectRoot: options.projectRoot,
+        testEnvironment: options.testEnvironment,
+    });
+}
+async function normalizeOptions(tree, options) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const addPlugin = process.env.NX_ADD_PLUGINS !== 'false' &&
+        nxJson.useInferencePlugins !== false;
+    options.addPlugin ??= addPlugin;
+    /**
+     * We are deprecating the compiler and the buildable options.
+     * However, we want to keep the existing behavior for now.
+     *
+     * So, if the user has not provided a bundler, we will use the compiler option, if any.
+     *
+     * If the user has not provided a bundler and no compiler, but has set buildable to true,
+     * we will use tsc, since that is the compiler the old generator used to default to, if buildable was true
+     * and no compiler was provided.
+     *
+     * If the user has not provided a bundler and no compiler, and has not set buildable to true, then
+     * set the bundler to tsc, to preserve old default behaviour (buildable: true by default).
+     *
+     * If it's publishable, we need to build the code before publishing it, so again
+     * we default to `tsc`. In the previous version of this, it would set `buildable` to true
+     * and that would default to `tsc`.
+     *
+     * In the past, the only way to get a non-buildable library was to set buildable to false.
+     * Now, the only way to get a non-buildble library is to set bundler to none.
+     * By default, with nothing provided, libraries are buildable with `@nx/js:tsc`.
+     */
+    options.bundler = options.bundler ?? options.compiler ?? 'tsc';
+    // ensure programmatic runs have an expected default
+    if (!options.config) {
+        options.config = 'project';
+    }
+    if (options.publishable) {
+        if (!options.importPath) {
+            throw new Error(`For publishable libs you have to provide a proper "--importPath" which needs to be a valid npm package name (e.g. my-awesome-lib or @myorg/my-lib)`);
+        }
+        if (options.bundler === 'none') {
+            options.bundler = 'tsc';
+        }
+    }
+    // This is to preserve old behavior, buildable: false
+    if (options.publishable === false && options.buildable === false) {
+        options.bundler = 'none';
+    }
+    const { Linter } = (0, devkit_1.ensurePackage)('@nx/eslint', versions_1.nxVersion);
+    if (options.config === 'npm-scripts') {
+        options.unitTestRunner = 'none';
+        options.linter = Linter.None;
+        options.bundler = 'none';
+    }
+    if ((options.bundler === 'swc' || options.bundler === 'rollup') &&
+        options.skipTypeCheck == null) {
+        options.skipTypeCheck = false;
+    }
+    if (!options.unitTestRunner && options.bundler === 'vite') {
+        options.unitTestRunner = 'vitest';
+    }
+    else if (!options.unitTestRunner && options.config !== 'npm-scripts') {
+        options.unitTestRunner = 'jest';
+    }
+    if (!options.linter && options.config !== 'npm-scripts') {
+        options.linter = Linter.EsLint;
+    }
+    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,
+        rootProject: options.rootProject,
+        callingGenerator: '@nx/js:library',
+    });
+    options.rootProject = projectRoot === '.';
+    const fileName = getCaseAwareFileName({
+        fileName: options.simpleName
+            ? projectNames.projectSimpleName
+            : projectNames.projectFileName,
+        pascalCaseFiles: options.pascalCaseFiles,
+    });
+    const parsedTags = options.tags
+        ? options.tags.split(',').map((s) => s.trim())
+        : [];
+    options.minimal ??= false;
+    return {
+        ...options,
+        fileName,
+        name: projectName,
+        projectNames,
+        projectRoot,
+        parsedTags,
+        importPath,
+    };
+}
+function getCaseAwareFileName(options) {
+    const normalized = (0, devkit_1.names)(options.fileName);
+    return options.pascalCaseFiles ? normalized.className : normalized.fileName;
+}
+function addProjectDependencies(tree, options) {
+    if (options.bundler == 'esbuild') {
+        return (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+            '@nx/esbuild': versions_1.nxVersion,
+            '@types/node': versions_1.typesNodeVersion,
+            esbuild: versions_1.esbuildVersion,
+        });
+    }
+    else if (options.bundler == 'rollup') {
+        return (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { '@nx/rollup': versions_1.nxVersion, '@types/node': versions_1.typesNodeVersion });
+    }
+    else {
+        return (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { '@types/node': versions_1.typesNodeVersion });
+    }
+    // Vite is being installed in the next step if bundler is vite
+    // noop
+    return () => { };
+}
+function getBuildExecutor(bundler) {
+    switch (bundler) {
+        case 'esbuild':
+            return `@nx/esbuild:esbuild`;
+        case 'rollup':
+            return `@nx/rollup:rollup`;
+        case 'swc':
+        case 'tsc':
+            return `@nx/js:${bundler}`;
+        case 'vite':
+            return `@nx/vite:build`;
+        case 'none':
+        default:
+            return undefined;
+    }
+}
+function getOutputPath(options) {
+    const parts = [defaultOutputDirectory];
+    if (options.projectRoot === '.') {
+        parts.push(options.name);
+    }
+    else {
+        parts.push(options.projectRoot);
+    }
+    return (0, devkit_1.joinPathFragments)(...parts);
+}
+function createProjectTsConfigJson(tree, options) {
+    const tsconfig = {
+        extends: options.rootProject
+            ? undefined
+            : (0, ts_config_1.getRelativePathToRootTsConfig)(tree, options.projectRoot),
+        compilerOptions: {
+            ...(options.rootProject ? create_ts_config_1.tsConfigBaseOptions : {}),
+            module: 'commonjs',
+            allowJs: options.js ? true : undefined,
+        },
+        files: [],
+        include: [],
+        references: [
+            {
+                path: './tsconfig.lib.json',
+            },
+        ],
+    };
+    (0, devkit_1.writeJson)(tree, (0, devkit_1.joinPathFragments)(options.projectRoot, 'tsconfig.json'), tsconfig);
+}
+function determineDependencies(options) {
+    switch (options.bundler) {
+        case 'tsc':
+            // importHelpers is true by default, so need to add tslib as a dependency.
+            return {
+                tslib: versions_1.tsLibVersion,
+            };
+        case 'swc':
+            // externalHelpers is true  by default, so need to add swc helpers as a dependency.
+            return {
+                '@swc/helpers': versions_1.swcHelpersVersion,
+            };
+        default: {
+            // In other cases (vite, rollup, esbuild), helpers are bundled so no need to add them as a dependency.
+            return {};
+        }
+    }
+}
+function determineEntryFields(options) {
+    switch (options.bundler) {
+        case 'tsc':
+            return {
+                type: 'commonjs',
+                main: './src/index.js',
+                typings: './src/index.d.ts',
+            };
+        case 'swc':
+            return {
+                type: 'commonjs',
+                main: './src/index.js',
+                typings: './src/index.d.ts',
+            };
+        case 'rollup':
+            return {
+                type: 'commonjs',
+                main: './index.cjs',
+                module: './index.js',
+                // typings is missing for rollup currently
+            };
+        case 'vite':
+            return {
+                // Since we're publishing both formats, skip the type field.
+                // Bundlers or Node will determine the entry point to use.
+                main: './index.js',
+                module: './index.mjs',
+                typings: './index.d.ts',
+            };
+        case 'esbuild':
+            // For libraries intended for Node, use CJS.
+            return {
+                type: 'commonjs',
+                main: './index.cjs',
+                // typings is missing for esbuild currently
+            };
+        default: {
+            return {
+                // CJS is the safest optional for now due to lack of support from some packages
+                // also setting `type: module` results in different resolution behavior (e.g. import 'foo' no longer resolves to 'foo/index.js')
+                type: 'commonjs',
+            };
+        }
+    }
+}
+function projectsConfigMatchesProject(projectsConfig, project) {
+    if (!projectsConfig) {
+        return false;
+    }
+    if (typeof projectsConfig === 'string') {
+        projectsConfig = [projectsConfig];
+    }
+    const graph = {
+        [project.name]: project,
+    };
+    const matchingProjects = (0, find_matching_projects_1.findMatchingProjects)(projectsConfig, graph);
+    return matchingProjects.includes(project.name);
+}
+async function addProjectToNxReleaseConfig(tree, options, projectConfiguration) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const addPreVersionCommand = () => {
+        const pmc = (0, devkit_1.getPackageManagerCommand)();
+        nxJson.release = {
+            ...nxJson.release,
+            version: {
+                preVersionCommand: `${pmc.dlx} nx run-many -t build`,
+                ...nxJson.release?.version,
+            },
+        };
+    };
+    if (!nxJson.release || (!nxJson.release.projects && !nxJson.release.groups)) {
+        // skip adding any projects configuration since the new project should be
+        // automatically included by nx release's default project detection logic
+        addPreVersionCommand();
+        (0, devkit_1.writeJson)(tree, 'nx.json', nxJson);
+        return;
+    }
+    const project = {
+        name: options.name,
+        type: 'lib',
+        data: {
+            root: projectConfiguration.root,
+            tags: projectConfiguration.tags,
+        },
+    };
+    if (projectsConfigMatchesProject(nxJson.release.projects, project)) {
+        devkit_1.output.log({
+            title: `Project already included in existing release configuration`,
+        });
+        addPreVersionCommand();
+        (0, devkit_1.writeJson)(tree, 'nx.json', nxJson);
+        return;
+    }
+    if (Array.isArray(nxJson.release.projects)) {
+        nxJson.release.projects.push(options.name);
+        addPreVersionCommand();
+        (0, devkit_1.writeJson)(tree, 'nx.json', nxJson);
+        devkit_1.output.log({
+            title: `Added project to existing release configuration`,
+        });
+    }
+    if (nxJson.release.groups) {
+        const allGroups = Object.entries(nxJson.release.groups);
+        for (const [name, group] of allGroups) {
+            if (projectsConfigMatchesProject(group.projects, project)) {
+                addPreVersionCommand();
+                (0, devkit_1.writeJson)(tree, 'nx.json', nxJson);
+                return `Project already included in existing release configuration for group ${name}`;
+            }
+        }
+        devkit_1.output.warn({
+            title: `Could not find a release group that includes ${options.name}`,
+            bodyLines: [
+                `Ensure that ${options.name} is included in a release group's "projects" list in nx.json so it can be published with "nx release"`,
+            ],
+        });
+        addPreVersionCommand();
+        (0, devkit_1.writeJson)(tree, 'nx.json', nxJson);
+        return;
+    }
+    if (typeof nxJson.release.projects === 'string') {
+        nxJson.release.projects = [nxJson.release.projects, options.name];
+        addPreVersionCommand();
+        (0, devkit_1.writeJson)(tree, 'nx.json', nxJson);
+        devkit_1.output.log({
+            title: `Added project to existing release configuration`,
+        });
+        return;
+    }
+}
+function logNxReleaseDocsInfo() {
+    devkit_1.output.log({
+        title: `📦 To learn how to publish this library, see https://nx.dev/core-features/manage-releases.`,
+    });
+}
+exports.default = libraryGenerator;