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

package/src/generators/release-version/test-utils/create-workspace-with-package-dependencies.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWorkspaceWithPackageDependencies = void 0;
+const devkit_1 = require("@nx/devkit");
+function createWorkspaceWithPackageDependencies(tree, projectAndPackageData) {
+    const projectGraph = {
+        nodes: {},
+        dependencies: {},
+    };
+    for (const [projectName, data] of Object.entries(projectAndPackageData)) {
+        const packageJsonContents = {
+            name: data.packageName,
+            version: data.version,
+        };
+        for (const dependency of data.localDependencies) {
+            const dependencyPackageName = projectAndPackageData[dependency.projectName].packageName;
+            packageJsonContents[dependency.dependencyCollection] = {
+                ...packageJsonContents[dependency.dependencyCollection],
+                [dependencyPackageName]: dependency.version,
+            };
+        }
+        // add the project and its nx project level dependencies to the projectGraph
+        projectGraph.nodes[projectName] = {
+            name: projectName,
+            type: 'lib',
+            data: {
+                root: data.projectRoot,
+            },
+        };
+        projectGraph.dependencies[projectName] = data.localDependencies.map((dependency) => ({
+            source: projectName,
+            target: dependency.projectName,
+            type: 'static',
+        }));
+        // create the package.json in the tree
+        (0, devkit_1.writeJson)(tree, data.packageJsonPath, packageJsonContents);
+    }
+    return projectGraph;
+}
+exports.createWorkspaceWithPackageDependencies = createWorkspaceWithPackageDependencies;

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

@@ -0,0 +1,12 @@
+import { PackageJson } from 'nx/src/utils/package-json';
+export declare class Package {
+    private packageJson;
+    name: string;
+    version: string;
+    location: string;
+    constructor(packageJson: PackageJson, workspaceRoot: string, workspaceRelativeLocation: string);
+    getLocalDependency(depName: string): {
+        collection: 'dependencies' | 'devDependencies' | 'optionalDependencies';
+        spec: string;
+    } | null;
+}

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Package = void 0;
+const devkit_1 = require("@nx/devkit");
+class Package {
+    constructor(packageJson, workspaceRoot, workspaceRelativeLocation) {
+        this.packageJson = packageJson;
+        this.name = packageJson.name;
+        this.version = packageJson.version;
+        this.location = (0, devkit_1.joinPathFragments)(workspaceRoot, workspaceRelativeLocation);
+    }
+    getLocalDependency(depName) {
+        if (this.packageJson.dependencies?.[depName]) {
+            return {
+                collection: 'dependencies',
+                spec: this.packageJson.dependencies[depName],
+            };
+        }
+        if (this.packageJson.devDependencies?.[depName]) {
+            return {
+                collection: 'devDependencies',
+                spec: this.packageJson.devDependencies[depName],
+            };
+        }
+        if (this.packageJson.optionalDependencies?.[depName]) {
+            return {
+                collection: 'optionalDependencies',
+                spec: this.packageJson.optionalDependencies[depName],
+            };
+        }
+        return null;
+    }
+}
+exports.Package = Package;

package/src/generators/release-version/utils/resolve-local-package-dependencies.d.ts

@@ -0,0 +1,12 @@
+import { ProjectGraph, ProjectGraphDependency, ProjectGraphProjectNode, Tree } from '@nx/devkit';
+interface LocalPackageDependency extends ProjectGraphDependency {
+    /**
+     * The rawVersionSpec contains the value of the version spec as it was defined in the package.json
+     * of the dependent project. This can be useful in cases where the version spec is a range, path or
+     * workspace reference, and it needs to be be reverted to that original value as part of the release.
+     */
+    rawVersionSpec: string;
+    dependencyCollection: 'dependencies' | 'devDependencies' | 'optionalDependencies';
+}
+export declare function resolveLocalPackageDependencies(tree: Tree, projectGraph: ProjectGraph, filteredProjects: ProjectGraphProjectNode[], projectNameToPackageRootMap: Map<string, string>, resolvePackageRoot: (projectNode: ProjectGraphProjectNode) => string, includeAll?: boolean): Record<string, LocalPackageDependency[]>;
+export {};

package/src/generators/release-version/utils/resolve-local-package-dependencies.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveLocalPackageDependencies = void 0;
+const devkit_1 = require("@nx/devkit");
+const semver_1 = require("semver");
+const package_1 = require("./package");
+const resolve_version_spec_1 = require("./resolve-version-spec");
+function resolveLocalPackageDependencies(tree, projectGraph, filteredProjects, projectNameToPackageRootMap, resolvePackageRoot, includeAll = false) {
+    const localPackageDependencies = {};
+    const projectNodeToPackageMap = new Map();
+    const projects = includeAll
+        ? Object.values(projectGraph.nodes)
+        : filteredProjects;
+    // Iterate through the projects being released and resolve any relevant package.json data
+    for (const projectNode of projects) {
+        // Resolve the package.json path for the project, taking into account any custom packageRoot settings
+        let packageRoot = projectNameToPackageRootMap.get(projectNode.name);
+        // packageRoot wasn't added to the map yet, try to resolve it dynamically
+        if (!packageRoot && includeAll) {
+            packageRoot = resolvePackageRoot(projectNode);
+            if (!packageRoot) {
+                continue;
+            }
+            // Append it to the map for later use within the release version generator
+            projectNameToPackageRootMap.set(projectNode.name, packageRoot);
+        }
+        const packageJsonPath = (0, devkit_1.joinPathFragments)(packageRoot, 'package.json');
+        if (!tree.exists(packageJsonPath)) {
+            continue;
+        }
+        const packageJson = (0, devkit_1.readJson)(tree, packageJsonPath);
+        const pkg = new package_1.Package(packageJson, devkit_1.workspaceRoot, packageRoot);
+        projectNodeToPackageMap.set(projectNode, pkg);
+    }
+    // populate local npm package dependencies
+    for (const projectDeps of Object.values(projectGraph.dependencies)) {
+        const workspaceDeps = projectDeps.filter((dep) => !isExternalNpmDependency(dep.target) &&
+            !isExternalNpmDependency(dep.source));
+        for (const dep of workspaceDeps) {
+            const source = projectGraph.nodes[dep.source];
+            const target = projectGraph.nodes[dep.target];
+            if (!source ||
+                !projectNodeToPackageMap.has(source) ||
+                !target ||
+                !projectNodeToPackageMap.has(target)) {
+                // only relevant for dependencies between two workspace projects with Package objects
+                continue;
+            }
+            const sourcePackage = projectNodeToPackageMap.get(source);
+            const targetPackage = projectNodeToPackageMap.get(target);
+            const sourceNpmDependency = sourcePackage.getLocalDependency(targetPackage.name);
+            if (!sourceNpmDependency) {
+                continue;
+            }
+            const targetVersionSpec = (0, resolve_version_spec_1.resolveVersionSpec)(targetPackage.name, targetPackage.version, sourceNpmDependency.spec, sourcePackage.location);
+            const targetMatchesRequirement = 
+            // For file: and workspace: protocols the targetVersionSpec could be a path, so we check if it matches the target's location
+            targetVersionSpec === targetPackage.location ||
+                (0, semver_1.satisfies)(targetPackage.version, targetVersionSpec);
+            if (targetMatchesRequirement) {
+                // track only local package dependencies that are satisfied by the target's version
+                localPackageDependencies[dep.source] = [
+                    ...(localPackageDependencies[dep.source] || []),
+                    {
+                        ...dep,
+                        dependencyCollection: sourceNpmDependency.collection,
+                        rawVersionSpec: sourceNpmDependency.spec,
+                    },
+                ];
+            }
+        }
+    }
+    return localPackageDependencies;
+}
+exports.resolveLocalPackageDependencies = resolveLocalPackageDependencies;
+function isExternalNpmDependency(dep) {
+    return dep.startsWith('npm:');
+}

package/src/generators/release-version/utils/resolve-version-spec.d.ts

@@ -0,0 +1 @@
+export declare function resolveVersionSpec(name: string, version: string, spec: string, location?: string): string;

package/src/generators/release-version/utils/resolve-version-spec.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveVersionSpec = void 0;
+const npa = require("npm-package-arg");
+const devkit_1 = require("@nx/devkit");
+function resolveVersionSpec(name, version, spec, location) {
+    // yarn classic uses link instead of file, normalize to match what npm expects
+    spec = spec.replace(/^link:/, 'file:');
+    // Support workspace: protocol for pnpm and yarn 2+ (https://pnpm.io/workspaces#workspace-protocol-workspace)
+    const isWorkspaceSpec = /^workspace:/.test(spec);
+    if (isWorkspaceSpec) {
+        spec = spec.replace(/^workspace:/, '');
+        // replace aliases (https://pnpm.io/workspaces#referencing-workspace-packages-through-aliases)
+        if (spec === '*' || spec === '^' || spec === '~') {
+            if (version) {
+                const prefix = spec === '*' ? '' : spec;
+                spec = `${prefix}${version}`;
+            }
+            else {
+                spec = '*';
+            }
+        }
+    }
+    const npaResult = npa.resolve(name, spec, location);
+    return npaResult.fetchSpec.includes('\\')
+        ? (0, devkit_1.normalizePath)(npaResult.fetchSpec)
+        : npaResult.fetchSpec;
+}
+exports.resolveVersionSpec = resolveVersionSpec;

package/src/generators/release-version/utils/update-lock-file.d.ts

@@ -0,0 +1,5 @@
+export declare function updateLockFile(cwd: string, { dryRun, verbose, generatorOptions, }: {
+    dryRun?: boolean;
+    verbose?: boolean;
+    generatorOptions?: Record<string, unknown>;
+}): Promise<string[]>;

package/src/generators/release-version/utils/update-lock-file.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateLockFile = void 0;
+const devkit_1 = require("@nx/devkit");
+const child_process_1 = require("child_process");
+const client_1 = require("nx/src/daemon/client/client");
+// eslint-disable-next-line @typescript-eslint/no-restricted-imports
+const lock_file_1 = require("nx/src/plugins/js/lock-file/lock-file");
+const semver_1 = require("semver");
+async function updateLockFile(cwd, { dryRun, verbose, generatorOptions, }) {
+    if (generatorOptions?.skipLockFileUpdate) {
+        if (verbose) {
+            console.log('\nSkipped lock file update because skipLockFileUpdate was set.');
+        }
+        return [];
+    }
+    const packageManager = (0, devkit_1.detectPackageManager)(cwd);
+    if (packageManager === 'yarn' &&
+        !(0, semver_1.gte)((0, devkit_1.getPackageManagerVersion)(packageManager), '2.0.0')) {
+        // yarn classic does not store workspace data in the lock file, so we don't need to update it
+        if (verbose) {
+            console.log('\nSkipped lock file update because it is not necessary for Yarn Classic.');
+        }
+        return [];
+    }
+    const workspacesEnabled = (0, devkit_1.isWorkspacesEnabled)(packageManager, cwd);
+    if (!workspacesEnabled) {
+        if (verbose) {
+            console.log(`\nSkipped lock file update because ${packageManager} workspaces are not enabled.`);
+        }
+        return [];
+    }
+    const isDaemonEnabled = client_1.daemonClient.enabled();
+    if (!dryRun && isDaemonEnabled) {
+        // if not in dry-run temporarily stop the daemon, as it will error if the lock file is updated
+        await client_1.daemonClient.stop();
+    }
+    const packageManagerCommands = (0, devkit_1.getPackageManagerCommand)(packageManager);
+    let installArgs = generatorOptions?.installArgs || '';
+    devkit_1.output.logSingleLine(`Updating ${packageManager} lock file`);
+    let env = {};
+    if (generatorOptions?.installIgnoreScripts) {
+        if (packageManager === 'yarn') {
+            env = { YARN_ENABLE_SCRIPTS: 'false' };
+        }
+        else {
+            // npm and pnpm use the same --ignore-scripts option
+            installArgs = `${installArgs} --ignore-scripts`.trim();
+        }
+    }
+    const lockFile = (0, lock_file_1.getLockFileName)(packageManager);
+    const command = `${packageManagerCommands.updateLockFile} ${installArgs}`.trim();
+    if (verbose) {
+        if (dryRun) {
+            console.log(`Would update ${lockFile} with the following command, but --dry-run was set:`);
+        }
+        else {
+            console.log(`Updating ${lockFile} with the following command:`);
+        }
+        console.log(command);
+    }
+    if (dryRun) {
+        return [];
+    }
+    execLockFileUpdate(command, cwd, env);
+    if (isDaemonEnabled) {
+        try {
+            await client_1.daemonClient.startInBackground();
+        }
+        catch (e) {
+            // If the daemon fails to start, we don't want to prevent the user from continuing, so we just log the error and move on
+            if (verbose) {
+                devkit_1.output.warn({
+                    title: 'Unable to restart the Nx Daemon. It will be disabled until you run "nx reset"',
+                    bodyLines: [e.message],
+                });
+            }
+        }
+    }
+    return [lockFile];
+}
+exports.updateLockFile = updateLockFile;
+function execLockFileUpdate(command, cwd, env = {}) {
+    try {
+        (0, child_process_1.execSync)(command, {
+            cwd,
+            env: {
+                ...process.env,
+                ...env,
+            },
+        });
+    }
+    catch (e) {
+        devkit_1.output.error({
+            title: `Error updating lock file with command '${command}'`,
+            bodyLines: [
+                `Verify that '${command}' succeeds when run from the workspace root.`,
+                `To configure a string of arguments to be passed to this command, set the 'release.version.generatorOptions.installArgs' property in nx.json.`,
+                `To ignore install lifecycle scripts, set 'release.version.generatorOptions.installIgnoreScripts' to true in nx.json.`,
+                `To disable this step entirely, set 'release.version.skipLockFileUpdate' to true in nx.json.`,
+            ],
+        });
+        throw e;
+    }
+}

package/src/generators/setup-build/generator.d.ts

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

package/src/generators/setup-build/generator.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupBuildGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+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");
+const add_build_target_defaults_1 = require("@nx/devkit/src/generators/add-build-target-defaults");
+async function setupBuildGenerator(tree, options) {
+    const tasks = [];
+    const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    const buildTarget = options.buildTarget ?? 'build';
+    const prevBuildOptions = project.targets?.[buildTarget]?.options;
+    project.targets ??= {};
+    let mainFile;
+    if (prevBuildOptions?.main) {
+        mainFile = prevBuildOptions.main;
+    }
+    else if (options.main) {
+        mainFile = options.main;
+    }
+    else {
+        const root = project.sourceRoot ?? project.root;
+        for (const f of [
+            (0, devkit_1.joinPathFragments)(root, 'main.ts'),
+            (0, devkit_1.joinPathFragments)(root, 'main.js'),
+            (0, devkit_1.joinPathFragments)(root, 'index.ts'),
+            (0, devkit_1.joinPathFragments)(root, 'index.js'),
+        ]) {
+            if (tree.exists(f)) {
+                mainFile = f;
+                break;
+            }
+        }
+    }
+    if (!mainFile || !tree.exists(mainFile)) {
+        throw new Error(`Cannot locate a main file for ${options.project}. Please specify one using --main=<file-path>.`);
+    }
+    let tsConfigFile;
+    if (prevBuildOptions?.tsConfig) {
+        tsConfigFile = prevBuildOptions.tsConfig;
+    }
+    else if (options.tsConfig) {
+        tsConfigFile = options.tsConfig;
+    }
+    else {
+        for (const f of [
+            'tsconfig.lib.json',
+            'tsconfig.app.json',
+            'tsconfig.json',
+        ]) {
+            const candidate = (0, devkit_1.joinPathFragments)(project.root, f);
+            if (tree.exists(candidate)) {
+                tsConfigFile = candidate;
+                break;
+            }
+        }
+    }
+    if (!tsConfigFile || !tree.exists(tsConfigFile)) {
+        throw new Error(`Cannot locate a tsConfig file for ${options.project}. Please specify one using --tsConfig=<file-path>.`);
+    }
+    switch (options.bundler) {
+        case 'vite': {
+            const { viteConfigurationGenerator } = (0, devkit_1.ensurePackage)('@nx/vite', versions_1.nxVersion);
+            const task = await viteConfigurationGenerator(tree, {
+                buildTarget: options.buildTarget,
+                project: options.project,
+                newProject: true,
+                uiFramework: 'none',
+                includeVitest: false,
+                includeLib: true,
+                skipFormat: true,
+            });
+            tasks.push(task);
+            break;
+        }
+        case 'esbuild': {
+            const { configurationGenerator } = (0, devkit_1.ensurePackage)('@nx/esbuild', versions_1.nxVersion);
+            const task = await configurationGenerator(tree, {
+                main: mainFile,
+                buildTarget: options.buildTarget,
+                project: options.project,
+                skipFormat: true,
+                skipValidation: true,
+            });
+            tasks.push(task);
+            break;
+        }
+        case 'rollup': {
+            const { configurationGenerator } = (0, devkit_1.ensurePackage)('@nx/rollup', versions_1.nxVersion);
+            const task = await configurationGenerator(tree, {
+                buildTarget: options.buildTarget,
+                main: mainFile,
+                tsConfig: tsConfigFile,
+                project: options.project,
+                compiler: 'tsc',
+                format: ['cjs', 'esm'],
+                skipFormat: true,
+                skipValidation: true,
+            });
+            tasks.push(task);
+            break;
+        }
+        case 'tsc': {
+            (0, add_build_target_defaults_1.addBuildTargetDefaults)(tree, '@nx/js:tsc');
+            const outputPath = (0, devkit_1.joinPathFragments)('dist', project.root);
+            project.targets[buildTarget] = {
+                executor: `@nx/js:tsc`,
+                outputs: ['{options.outputPath}'],
+                options: {
+                    outputPath,
+                    main: mainFile,
+                    tsConfig: tsConfigFile,
+                    assets: [],
+                },
+            };
+            (0, devkit_1.updateProjectConfiguration)(tree, options.project, project);
+            break;
+        }
+        case 'swc': {
+            (0, add_build_target_defaults_1.addBuildTargetDefaults)(tree, '@nx/js:swc');
+            const outputPath = (0, devkit_1.joinPathFragments)('dist', project.root);
+            project.targets[buildTarget] = {
+                executor: `@nx/js:swc`,
+                outputs: ['{options.outputPath}'],
+                options: {
+                    outputPath,
+                    main: mainFile,
+                    tsConfig: tsConfigFile,
+                    assets: [],
+                },
+            };
+            (0, devkit_1.updateProjectConfiguration)(tree, options.project, project);
+            (0, add_swc_dependencies_1.addSwcDependencies)(tree);
+            (0, add_swc_config_1.addSwcConfig)(tree, project.root, 'es6');
+        }
+    }
+    await (0, devkit_1.formatFiles)(tree);
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+exports.setupBuildGenerator = setupBuildGenerator;
+exports.default = setupBuildGenerator;

package/src/generators/setup-build/schema.d.ts

@@ -0,0 +1,7 @@
+export interface SetupBuildGeneratorSchema {
+  project: string;
+  bundler: 'tsc' | 'swc' | 'vite' | 'rollup' | 'esbuild';
+  main?: string;
+  tsConfig?: string;
+  buildTarget?: string;
+}

package/src/generators/setup-build/schema.json

@@ -0,0 +1,42 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "SetupBuild",
+  "title": "Setup Build",
+  "description": "Sets up build target for a project.",
+  "type": "object",
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "Project to add the build target to.",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "Which project do you want to add build to?",
+      "x-dropdown": "projects",
+      "x-priority": "important"
+    },
+    "bundler": {
+      "description": "The bundler to use to build the project.",
+      "type": "string",
+      "enum": ["tsc", "swc", "rollup", "vite", "esbuild"],
+      "default": "tsc",
+      "x-prompt": "Which bundler would you like to use to build the project?",
+      "x-priority": "important"
+    },
+    "main": {
+      "description": "The path to the main entry file, relative to workspace root. Defaults to <project>/src/index.ts or <project>/src/main.ts.",
+      "type": "string"
+    },
+    "tsConfig": {
+      "description": "The path to the tsConfig file, relative to workspace root. Defaults to <project>/tsconfig.lib.json or <project>/tsconfig.app.json depending on project type.",
+      "type": "string"
+    },
+    "buildTarget": {
+      "description": "The build target to add.",
+      "type": "string",
+      "default": "build"
+    }
+  },
+  "required": ["project", "bundler"]
+}

package/src/generators/setup-verdaccio/files/config.yml

@@ -0,0 +1,28 @@
+# path to a directory with all packages
+storage: ../tmp/local-registry/storage
+
+# a list of other known repositories we can talk to
+uplinks:
+  npmjs:
+    url: <%= npmUplinkRegistry %>
+    maxage: 60m
+
+packages:
+  '**':
+    # give all users (including non-authenticated users) full access
+    # because it is a local registry
+    access: $all
+    publish: $all
+    unpublish: $all
+
+    # if package is not available locally, proxy requests to npm registry
+    proxy: npmjs
+
+# log settings
+logs:
+  type: stdout
+  format: pretty
+  level: warn
+
+publish:
+  allow_offline: true # set offline to true to allow publish offline

package/src/generators/setup-verdaccio/generator.d.ts

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

package/src/generators/setup-verdaccio/generator.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupVerdaccio = void 0;
+const devkit_1 = require("@nx/devkit");
+const path = require("path");
+const versions_1 = require("../../utils/versions");
+const child_process_1 = require("child_process");
+async function setupVerdaccio(tree, options) {
+    if (!tree.exists('.verdaccio/config.yml')) {
+        (0, devkit_1.generateFiles)(tree, path.join(__dirname, 'files'), '.verdaccio', {
+            npmUplinkRegistry: (0, child_process_1.execSync)('npm config get registry')?.toString()?.trim() ??
+                'https://registry.npmjs.org',
+        });
+    }
+    const verdaccioTarget = {
+        executor: '@nx/js:verdaccio',
+        options: {
+            port: 4873,
+            config: '.verdaccio/config.yml',
+            storage: 'tmp/local-registry/storage',
+        },
+    };
+    if (!tree.exists('project.json')) {
+        const { name } = (0, devkit_1.readJson)(tree, 'package.json');
+        (0, devkit_1.updateJson)(tree, 'package.json', (json) => {
+            if (!json.nx) {
+                json.nx = {
+                    includedScripts: [],
+                };
+            }
+            return json;
+        });
+        (0, devkit_1.addProjectConfiguration)(tree, name, {
+            root: '.',
+            targets: {
+                ['local-registry']: verdaccioTarget,
+            },
+        });
+    }
+    else {
+        // use updateJson instead of updateProjectConfiguration due to unknown project name
+        (0, devkit_1.updateJson)(tree, 'project.json', (json) => {
+            if (!json.targets) {
+                json.targets = {};
+            }
+            json.targets['local-registry'] ??= verdaccioTarget;
+            return json;
+        });
+    }
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { verdaccio: versions_1.verdaccioVersion });
+}
+exports.setupVerdaccio = setupVerdaccio;
+exports.default = setupVerdaccio;

package/src/generators/setup-verdaccio/schema.d.ts

@@ -0,0 +1,3 @@
+export interface SetupVerdaccioGeneratorSchema {
+  skipFormat: boolean;
+}

package/src/generators/setup-verdaccio/schema.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "SetupVerdaccio",
+  "title": "Setup Verdaccio",
+  "description": "Setup Verdaccio local-registry.",
+  "type": "object",
+  "properties": {
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false,
+      "x-priority": "internal"
+    }
+  },
+  "required": []
+}

package/src/index.d.ts

@@ -0,0 +1,17 @@
+export * from './utils/typescript/add-tslib-dependencies';
+export * from './utils/typescript/load-ts-transformers';
+export * from './utils/typescript/print-diagnostics';
+export * from './utils/typescript/run-type-check';
+export * from './utils/typescript/get-source-nodes';
+export * from './utils/compiler-helper-dependency';
+export * from './utils/typescript/ts-config';
+export * from './utils/typescript/create-ts-config';
+export * from './utils/typescript/ast-utils';
+export * from './utils/package-json';
+export * from './utils/assets';
+export * from './utils/package-json/update-package-json';
+export * from './utils/package-json/create-entry-points';
+export { libraryGenerator } from './generators/library/library';
+export { initGenerator } from './generators/init/init';
+export { createLockFile, getLockFileName, } from 'nx/src/plugins/js/lock-file/lock-file';
+export { createPackageJson } from 'nx/src/plugins/js/package-json/create-package-json';