@nx/dotnet 0.0.1 → 22.0.0-beta.8

package/README.md

@@ -1,7 +1,120 @@
-# nx-plugin
+<p style="text-align: center;">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-dark.svg">
+    <img alt="Nx - Smart Repos · Fast Builds" src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-light.svg" width="100%">
+  </picture>
+</p>
 
-This library was generated with [Nx](https://nx.dev).
+<div style="text-align: center;">
 
-## Building
+[![CircleCI](https://circleci.com/gh/nrwl/nx.svg?style=svg)](https://circleci.com/gh/nrwl/nx)
+[![License](https://img.shields.io/npm/l/@nx/workspace.svg?style=flat-square)]()
+[![NPM Version](https://badge.fury.io/js/nx.svg)](https://www.npmjs.com/package/nx)
+[![Semantic Release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg?style=flat-square)]()
+[![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/)
+[![Join the chat at https://gitter.im/nrwl-nx/community](https://badges.gitter.im/nrwl-nx/community.svg)](https://gitter.im/nrwl-nx/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![Join us on the Official Nx Discord Server](https://img.shields.io/discord/1143497901675401286?label=discord)](https://go.nx.dev/community)
+
+</div>
+
+
+<hr>
+
+# Nx: Smart Repos · Fast Builds
+
+Get to green PRs in half the time. Nx optimizes your builds, scales your CI, and fixes failed PRs. Built for developers and AI agents.
+
+## Build .NET with Nx
+
+The goal of `@nx/dotnet` is to make it easy and straightforward to build .NET applications in an Nx workspace. It provides intelligent project graph analysis, automatic dependency detection, and smart target configuration using MSBuild.
+
+### Getting Started
+
+#### Step 1: Add the .NET plugin to your Nx workspace
+
+```bash
+nx add @nx/dotnet
+```
+
+#### Step 2: Configure the plugin in your `nx.json`
+
+```json
+{
+  "plugins": ["@nx/dotnet"]
+}
+```
+
+#### Step 3: Create your .NET projects
+
+```bash
+# Create a console application
+dotnet new console -n MyApp
+
+# Create a class library
+dotnet new classlib -n MyLibrary
+
+# Create a test project
+dotnet new xunit -n MyApp.Tests
+```
+
+The plugin will automatically detect your .NET projects and configure appropriate Nx targets.
+
+#### Step 4: Run Build, Test, and other commands
+
+```bash
+# Build a project
+nx build my-app
+
+# Run tests
+nx test my-app-tests
+
+# Build with Release configuration
+nx build my-app --configuration Release
+
+# Create a NuGet package
+nx pack my-library
+
+# Publish an application
+nx publish my-app
+```
+
+## Getting Started
+
+### Creating an Nx Workspace
+
+**Using `npx`**
+
+```bash
+npx create-nx-workspace
+```
+
+**Using `npm init`**
+
+```bash
+npm init nx-workspace
+```
+
+**Using `yarn create`**
+
+```bash
+yarn create nx-workspace
+```
+
+### Adding Nx to an Existing Repository
+
+Run:
+
+```bash
+npx nx@latest init
+```
+
+## Documentation & Resources
+
+- [Nx.Dev: Documentation, Guides, Tutorials](https://nx.dev)
+- [Intro to Nx](https://nx.dev/getting-started/intro)
+- [Official Nx YouTube Channel](https://www.youtube.com/@NxDevtools)
+- [Blog Posts About Nx](https://nx.dev/blog)
+
+<p style="text-align: center;"><a href="https://nx.dev/#learning-materials" target="_blank" rel="noreferrer"><img src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-courses-and-videos.svg" 
+width="100%" alt="Nx - Smart Repos · Fast Builds"></a></p>
 
-Run `nx build nx-plugin` to build the library.

package/README.md__tmpl__

@@ -0,0 +1,70 @@
+<p style="text-align: center;">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-dark.svg">
+    <img alt="Nx - Smart Repos · Fast Builds" src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-light.svg" width="100%">
+  </picture>
+</p>
+
+{{links}}
+
+<hr>
+
+# Nx: Smart Repos · Fast Builds
+
+Get to green PRs in half the time. Nx optimizes your builds, scales your CI, and fixes failed PRs. Built for developers and AI agents.
+
+## Build .NET with Nx
+
+The goal of `@nx/dotnet` is to make it easy and straightforward to build .NET applications in an Nx workspace. It provides intelligent project graph analysis, automatic dependency detection, and smart target configuration using MSBuild.
+
+### Getting Started
+
+#### Step 1: Add the .NET plugin to your Nx workspace
+
+```bash
+nx add @nx/dotnet
+```
+
+#### Step 2: Configure the plugin in your `nx.json`
+
+```json
+{
+  "plugins": ["@nx/dotnet"]
+}
+```
+
+#### Step 3: Create your .NET projects
+
+```bash
+# Create a console application
+dotnet new console -n MyApp
+
+# Create a class library
+dotnet new classlib -n MyLibrary
+
+# Create a test project
+dotnet new xunit -n MyApp.Tests
+```
+
+The plugin will automatically detect your .NET projects and configure appropriate Nx targets.
+
+#### Step 4: Run Build, Test, and other commands
+
+```bash
+# Build a project
+nx build my-app
+
+# Run tests
+nx test my-app-tests
+
+# Build with Release configuration
+nx build my-app --configuration Release
+
+# Create a NuGet package
+nx pack my-library
+
+# Publish an application
+nx publish my-app
+```
+
+{{content}}

package/dist/analyzer/analyzer-client.d.ts

@@ -0,0 +1,39 @@
+import { ProjectConfiguration } from '@nx/devkit';
+export interface AnalysisSuccessResult {
+    nodesByFile: Record<string, ProjectConfiguration>;
+    referencesByRoot: Record<string, {
+        refs: string[];
+        sourceConfigFile: string;
+    }>;
+}
+export interface AnalysisErrorResult {
+    error: Error;
+}
+export type AnalysisResult = AnalysisSuccessResult | AnalysisErrorResult;
+export interface DotNetPluginOptions {
+    buildTargetName?: string;
+    testTargetName?: string;
+    cleanTargetName?: string;
+    restoreTargetName?: string;
+    publishTargetName?: string;
+    packTargetName?: string;
+}
+/**
+ * Get project analysis results for the given project files.
+ * Results are cached based on the content hash of all project files.
+ * This should be called by createNodes to populate the cache.
+ */
+export declare function analyzeProjects(projectFiles: string[], options?: DotNetPluginOptions): Promise<AnalysisResult>;
+/**
+ * Read the cached analysis results without running the analyzer.
+ * This should be called by createDependencies, which always runs after createNodes.
+ * If the cache is empty, returns an empty result (this shouldn't happen in normal operation).
+ */
+export declare function readCachedAnalysisResult(): AnalysisResult;
+/**
+ * Clear the cache (useful for testing)
+ */
+export declare function clearCache(): void;
+export declare function isAnalysisErrorResult(result: AnalysisResult): result is AnalysisErrorResult;
+export declare function isAnalysisSuccessResult(result: AnalysisResult): result is AnalysisSuccessResult;
+//# sourceMappingURL=analyzer-client.d.ts.map

package/dist/analyzer/analyzer-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzer-client.d.ts","sourceRoot":"","sources":["../../src/analyzer/analyzer-client.ts"],"names":[],"mappings":"AAIA,OAAO,EAGL,oBAAoB,EAErB,MAAM,YAAY,CAAC;AAKpB,MAAM,WAAW,qBAAqB;IAEpC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;IAElD,gBAAgB,EAAE,MAAM,CACtB,MAAM,EACN;QAAE,IAAI,EAAE,MAAM,EAAE,CAAC;QAAC,gBAAgB,EAAE,MAAM,CAAA;KAAE,CAC7C,CAAC;CACH;AACD,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,KAAK,CAAC;CACd;AACD,MAAM,MAAM,cAAc,GAAG,qBAAqB,GAAG,mBAAmB,CAAC;AA2CzE,MAAM,WAAW,mBAAmB;IAClC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAgJD;;;;GAIG;AACH,wBAAsB,eAAe,CACnC,YAAY,EAAE,MAAM,EAAE,EACtB,OAAO,CAAC,EAAE,mBAAmB,GAC5B,OAAO,CAAC,cAAc,CAAC,CA2DzB;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,IAAI,cAAc,CASzD;AAED;;GAEG;AACH,wBAAgB,UAAU,IAAI,IAAI,CAEjC;AAED,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,cAAc,GACrB,MAAM,IAAI,mBAAmB,CAE/B;AAED,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,cAAc,GACrB,MAAM,IAAI,qBAAqB,CAEjC"}

package/dist/analyzer/analyzer-client.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeProjects = analyzeProjects;
+exports.readCachedAnalysisResult = readCachedAnalysisResult;
+exports.clearCache = clearCache;
+exports.isAnalysisErrorResult = isAnalysisErrorResult;
+exports.isAnalysisSuccessResult = isAnalysisSuccessResult;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const devkit_1 = require("@nx/devkit");
+const workspace_context_1 = require("nx/src/utils/workspace-context");
+const cache_directory_1 = require("nx/src/utils/cache-directory");
+const file_hasher_1 = require("nx/src/hasher/file-hasher");
+const analyzerCaches = new Map();
+function getCachePathForOptionsHash(optionsHash) {
+    return (0, node_path_1.join)(cache_directory_1.workspaceDataDirectory, `dotnet-${optionsHash}.hash`);
+}
+function readAnalyzerCache(optionsHash) {
+    if (analyzerCaches.has(optionsHash)) {
+        return analyzerCaches.get(optionsHash);
+    }
+    const cacheFilePath = getCachePathForOptionsHash(optionsHash);
+    try {
+        return JSON.parse((0, node_fs_1.readFileSync)(cacheFilePath, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+function writeAnalyzerCache(optionsHash, cache) {
+    analyzerCaches.set(optionsHash, cache);
+    const cacheFilePath = getCachePathForOptionsHash(optionsHash);
+    const cacheDir = (0, node_path_1.dirname)(cacheFilePath);
+    if (!(0, node_fs_1.existsSync)(cacheDir)) {
+        (0, node_fs_1.mkdirSync)(cacheDir, { recursive: true });
+    }
+    try {
+        (0, devkit_1.writeJsonFile)(cacheFilePath, cache);
+    }
+    catch (error) {
+        devkit_1.logger.warn(`Failed to write .NET analyzer cache to ${cacheFilePath}: ${error.message}`);
+    }
+}
+let cache = null;
+/**
+ * Get the path to the msbuild-analyzer executable
+ */
+function getAnalyzerPath() {
+    const executableName = 'MsbuildAnalyzer.dll';
+    const possiblePaths = [
+        // When running from dist/packages/dotnet
+        (0, node_path_1.join)(__dirname, '..', 'lib', executableName),
+        // When running from packages/dotnet/src (development)
+        (0, node_path_1.join)(__dirname, 'lib', executableName),
+    ];
+    for (const path of possiblePaths) {
+        if ((0, node_fs_1.existsSync)(path)) {
+            return path;
+        }
+    }
+    throw new Error(`msbuild-analyzer not found at any expected location. Please build it first with: nx run dotnet:build-analyzer`);
+}
+/**
+ * Calculate a hash of all project files and Directory.Build.* files to determine if we need to re-analyze
+ */
+async function calculateProjectFilesHash(projectFiles) {
+    const hash = await (0, workspace_context_1.hashWithWorkspaceContext)(devkit_1.workspaceRoot, projectFiles.concat('Directory.Build.*', '**/Directory.Build.*'));
+    return hash;
+}
+/**
+ * Run the msbuild-analyzer and return the results.
+ * Uses stdin for large file lists to avoid ARG_MAX issues.
+ */
+function runAnalyzer(projectFiles, options) {
+    if (projectFiles.length === 0) {
+        return { nodesByFile: {}, referencesByRoot: {} };
+    }
+    const analyzerPath = getAnalyzerPath();
+    // Set environment variables for the analyzer process
+    const env = { ...process.env };
+    // TODO(@AgentEnder): Remove this if anyone reports issues with being unable
+    // to locate the .NET runtime, currently I'm not hitting the issue but when I was
+    // this solved it, and it took a deal of effort to track down so I'm leaving it here commented for now.
+    // In Nx 23, if no one has reported the issue, its probably safe to remove.
+    //
+    // On macOS/Linux, set library path to help find libhostfxr.dylib
+    // if (process.platform === 'darwin' || process.platform === 'linux') {
+    //   const dotnetRoot = process.env.DOTNET_ROOT || '/usr/local/share/dotnet';
+    //   const hostFxrPath = join(dotnetRoot, 'host', 'fxr');
+    //   if (existsSync(hostFxrPath)) {
+    //     const versions = readdirSync(hostFxrPath);
+    //     if (versions.length > 0) {
+    //       // Use the latest version
+    //       const latestVersion = versions.sort().reverse()[0];
+    //       const fxrDir = join(hostFxrPath, latestVersion);
+    //       const envVar =
+    //         process.platform === 'darwin'
+    //           ? 'DYLD_FALLBACK_LIBRARY_PATH'
+    //           : 'LD_LIBRARY_PATH';
+    //       const currentValue = env[envVar];
+    //       env[envVar] = currentValue ? `${fxrDir}:${currentValue}` : fxrDir;
+    //     }
+    //   }
+    // }
+    try {
+        let output;
+        // Prepare CLI arguments
+        const args = [analyzerPath, devkit_1.workspaceRoot];
+        // Add plugin options as JSON string if provided
+        if (options) {
+            args.push(JSON.stringify(options));
+        }
+        // Use stdin mode for large file lists to avoid ARG_MAX issues
+        const input = projectFiles.join('\n');
+        const result = (0, node_child_process_1.spawnSync)('dotnet', args, {
+            input,
+            encoding: 'utf-8',
+            maxBuffer: 10 * 1024 * 1024, // 10MB buffer
+            stdio: ['pipe', 'pipe', 'pipe'], // stdin, stdout, stderr
+            windowsHide: true,
+            env,
+        });
+        if (result.error) {
+            throw result.error;
+        }
+        if (result.status !== 0) {
+            throw new Error(`Analyzer exited with code ${result.status}: ${result.stderr}`);
+        }
+        // Output stderr (includes performance logs when NX_PERF_LOGGING=true)
+        if (result.stderr) {
+            console.error(result.stderr);
+        }
+        output = result.stdout;
+        return JSON.parse(output);
+    }
+    catch (error) {
+        const err = error;
+        if (err.stderr) {
+            devkit_1.logger.error(`msbuild-analyzer error: ${err.stderr}`);
+        }
+        throw new Error(`Failed to run msbuild-analyzer: ${err.message}${err.stderr ? `\n${err.stderr}` : ''}`);
+    }
+}
+/**
+ * Get project analysis results for the given project files.
+ * Results are cached based on the content hash of all project files.
+ * This should be called by createNodes to populate the cache.
+ */
+async function analyzeProjects(projectFiles, options) {
+    const filesHash = await calculateProjectFilesHash(projectFiles);
+    // Return cached results if the hash matches
+    if (cache &&
+        cache.hash === filesHash &&
+        // NOTE: We don't read from the cache here if it's an error result,
+        // to allow retrying analysis in case of transient errors or errors fixed
+        // that may not be reflected in the hash (like setting an env var).
+        isAnalysisSuccessResult(cache.result)) {
+        return cache.result;
+    }
+    const optionsHash = (0, file_hasher_1.hashObject)(options);
+    const analyzerCache = readAnalyzerCache(optionsHash);
+    const cachedResult = analyzerCache[filesHash];
+    if (cachedResult) {
+        // Update cache
+        cache = {
+            hash: filesHash,
+            result: cachedResult,
+        };
+        return cachedResult;
+    }
+    // Run the analyzer
+    try {
+        const result = runAnalyzer(projectFiles, options);
+        // Update local cache
+        cache = {
+            hash: filesHash,
+            result,
+        };
+        // Update persistent cache
+        writeAnalyzerCache(optionsHash, {
+            ...analyzerCache,
+            [filesHash]: result,
+        });
+        return result;
+    }
+    catch (error) {
+        const err = error;
+        // We save the error result in the local cache to avoid getting
+        // a different error when reading the cached result to createDependencies.
+        // Instead, we'll find a cached error and know that it was printed earlier.
+        // We DO NOT save error results to the on-disk cache to allow retries without
+        // running `nx reset`
+        const errorResult = {
+            error: err,
+        };
+        cache = {
+            hash: filesHash,
+            result: errorResult,
+        };
+        return errorResult;
+    }
+}
+/**
+ * Read the cached analysis results without running the analyzer.
+ * This should be called by createDependencies, which always runs after createNodes.
+ * If the cache is empty, returns an empty result (this shouldn't happen in normal operation).
+ */
+function readCachedAnalysisResult() {
+    if (cache) {
+        return cache.result;
+    }
+    // This shouldn't happen since createNodes always runs first
+    throw new Error('Analysis result cache is empty. Ensure that analyzeProjects() is called before readCachedAnalysisResult().');
+}
+/**
+ * Clear the cache (useful for testing)
+ */
+function clearCache() {
+    cache = null;
+}
+function isAnalysisErrorResult(result) {
+    return 'error' in result;
+}
+function isAnalysisSuccessResult(result) {
+    return !('error' in result);
+}

package/dist/generators/init/init.d.ts

@@ -0,0 +1,7 @@
+import { GeneratorCallback, Tree } from '@nx/devkit';
+import { InitGeneratorSchema } from './schema';
+export declare function initGenerator(tree: Tree, options: InitGeneratorSchema): Promise<GeneratorCallback>;
+export declare function updateGitIgnore(tree: Tree): void;
+export declare function updateNxJsonConfiguration(tree: Tree): void;
+export default initGenerator;
+//# sourceMappingURL=init.d.ts.map

package/dist/generators/init/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../src/generators/init/init.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,iBAAiB,EAIjB,IAAI,EAGL,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAG/C,wBAAsB,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,mBAAmB,8BA0B3E;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,QAqDzC;AAsBD,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,IAAI,QA0BnD;AAED,eAAe,aAAa,CAAC"}

package/dist/generators/init/init.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initGenerator = initGenerator;
+exports.updateGitIgnore = updateGitIgnore;
+exports.updateNxJsonConfiguration = updateNxJsonConfiguration;
+const devkit_1 = require("@nx/devkit");
+const ignore = require("ignore");
+const versions_1 = require("../../utils/versions");
+const has_dotnet_plugin_1 = require("../../utils/has-dotnet-plugin");
+async function initGenerator(tree, options) {
+    const tasks = [];
+    if (!options.skipPackageJson && tree.exists('package.json')) {
+        tasks.push((0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+            '@nx/dotnet': versions_1.nxVersion,
+        }, undefined, options.keepExistingVersions));
+    }
+    addPlugin(tree);
+    updateNxJsonConfiguration(tree);
+    updateGitIgnore(tree);
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+function updateGitIgnore(tree) {
+    const gitignorePath = '.gitignore';
+    if (tree.exists(gitignorePath)) {
+        let gitignore = tree.read(gitignorePath, 'utf-8');
+        const sectionHeader = '# .NET';
+        const potentialLinesToAdd = new Set(['**/bin/', '**/obj/', '/artifacts/']);
+        if (gitignore.includes(sectionHeader)) {
+            // Section already exists, do not modify
+            return;
+        }
+        // Line with issues -> files that would have been ignored.
+        const issues = new Map();
+        (0, devkit_1.visitNotIgnoredFiles)(tree, '.', (filePath) => {
+            for (const line of potentialLinesToAdd) {
+                const ig = ignore();
+                ig.add(line);
+                if (ig.ignores(filePath)) {
+                    if (!issues.has(line)) {
+                        issues.set(line, []);
+                    }
+                    issues.get(line).push(filePath);
+                }
+            }
+        });
+        let hasIssues = issues.size > 0;
+        if (hasIssues) {
+            devkit_1.logger.warn(`The following .gitignore entries cannot be added because they would ignore existing files:`);
+        }
+        for (const [line, files] of issues) {
+            potentialLinesToAdd.delete(line);
+            devkit_1.logger.warn(`- "${line}" would ignore the following existing files:\n` +
+                files.map((f) => `  - ${f}`).join('\n'));
+        }
+        if (hasIssues) {
+            devkit_1.logger.warn(`Review the above patterns and manually update your .gitignore as necessary.`);
+        }
+        if (potentialLinesToAdd.size > 0) {
+            gitignore += `\n${sectionHeader}\n`;
+            for (const line of potentialLinesToAdd) {
+                gitignore += `${line}\n`;
+            }
+            tree.write(gitignorePath, gitignore);
+        }
+    }
+}
+function addPlugin(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    if (!(0, has_dotnet_plugin_1.hasDotNetPlugin)(tree)) {
+        nxJson.plugins ??= [];
+        nxJson.plugins.push({
+            plugin: '@nx/dotnet',
+            options: {
+                buildTargetName: 'build',
+                testTargetName: 'test',
+                cleanTargetName: 'clean',
+                restoreTargetName: 'restore',
+                publishTargetName: 'publish',
+                packTargetName: 'pack',
+            },
+        });
+        (0, devkit_1.updateNxJson)(tree, nxJson);
+    }
+}
+function updateNxJsonConfiguration(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    if (!nxJson.namedInputs) {
+        nxJson.namedInputs = {};
+    }
+    // Default inputs include all project files
+    const defaultFilesSet = nxJson.namedInputs.default ?? [];
+    nxJson.namedInputs.default = Array.from(new Set([...defaultFilesSet, '{projectRoot}/**/*']));
+    // Production inputs exclude test files and build outputs
+    const productionFileSet = nxJson.namedInputs.production ?? [];
+    nxJson.namedInputs.production = Array.from(new Set([
+        ...productionFileSet,
+        'default',
+        '!{projectRoot}/**/*.Tests/**/*',
+        '!{projectRoot}/**/bin/**/*',
+        '!{projectRoot}/**/obj/**/*',
+    ]));
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+}
+exports.default = initGenerator;

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

@@ -0,0 +1,6 @@
+export interface InitGeneratorSchema {
+  skipFormat?: boolean;
+  skipPackageJson?: boolean;
+  keepExistingVersions?: boolean;
+  updatePackageScripts?: boolean;
+}

package/dist/generators/init/schema.json

@@ -0,0 +1,34 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxDotNetInitSchema",
+  "title": ".NET Init Generator",
+  "description": "Initializes a .NET project in the current workspace.",
+  "type": "object",
+  "properties": {
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false,
+      "x-priority": "internal"
+    },
+    "skipPackageJson": {
+      "type": "boolean",
+      "default": false,
+      "description": "Do not add dependencies to `package.json`.",
+      "x-priority": "internal"
+    },
+    "keepExistingVersions": {
+      "type": "boolean",
+      "x-priority": "internal",
+      "description": "Keep existing dependencies versions",
+      "default": false
+    },
+    "updatePackageScripts": {
+      "type": "boolean",
+      "x-priority": "internal",
+      "description": "Update `package.json` scripts with inferred targets",
+      "default": false
+    }
+  },
+  "required": []
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './plugin';
+export { DotNetPluginOptions } from './plugins/create-nodes';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AAEzB,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/index.js

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