@nx/gradle 18.2.0-beta.0

package/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2017-2023 Narwhal Technologies Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,68 @@
+<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 Monorepos · Fast CI" src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-light.svg" width="100%">
+  </picture>
+</p>
+
+<div style="text-align: center;">
+
+[![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/%40nrwl%2Fworkspace.svg)](https://www.npmjs.com/@nx/workspace)
+[![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 Monorepos · Fast CI
+
+Nx is a build system with built-in tooling and advanced CI capabilities. It helps you maintain and scale monorepos, both locally and on CI.
+
+This package is a [Gradle plugin for Nx](https://nx.dev/gradle/overview).
+
+## 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://blog.nrwl.io/nx/home)
+
+<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 Monorepos · Fast CI"></a></p>
+

package/generators.json

@@ -0,0 +1,11 @@
+{
+  "name": "Nx Gradle",
+  "version": "0.1",
+  "generators": {
+    "init": {
+      "factory": "./src/generators/init/init#initGenerator",
+      "schema": "./src/generators/init/schema.json",
+      "description": "Initializes a Gradle project in the current workspace"
+    }
+  }
+}

package/index.d.ts

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

package/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);

package/migrations.json

@@ -0,0 +1,4 @@
+{
+  "generators": {},
+  "packageJsonUpdates": {}
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@nx/gradle",
+  "version": "18.2.0-beta.0",
+  "private": false,
+  "description": "The Nx Plugin for gradle",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nrwl/nx.git",
+    "directory": "packages/gradle"
+  },
+  "keywords": [
+    "Monorepo",
+    "Java",
+    "Gradle",
+    "CLI"
+  ],
+  "main": "./index.js",
+  "typings": "./index.d.ts",
+  "author": "Victor Savkin",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/nrwl/nx/issues"
+  },
+  "homepage": "https://nx.dev",
+  "generators": "./generators.json",
+  "exports": {
+    ".": "./index.js",
+    "./package.json": "./package.json",
+    "./migrations.json": "./migrations.json",
+    "./generators.json": "./generators.json"
+  },
+  "nx-migrate": {
+    "migrations": "./migrations.json"
+  },
+  "dependencies": {
+    "@nx/devkit": "18.2.0-beta.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "commonjs"
+}

package/plugin.d.ts

@@ -0,0 +1,2 @@
+export { createDependencies } from './src/plugin/dependencies';
+export { createNodes } from './src/plugin/nodes';

package/plugin.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodes = exports.createDependencies = void 0;
+var dependencies_1 = require("./src/plugin/dependencies");
+Object.defineProperty(exports, "createDependencies", { enumerable: true, get: function () { return dependencies_1.createDependencies; } });
+var nodes_1 = require("./src/plugin/nodes");
+Object.defineProperty(exports, "createNodes", { enumerable: true, get: function () { return nodes_1.createNodes; } });

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

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

package/src/generators/init/init.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+const update_package_scripts_1 = require("@nx/devkit/src/utils/update-package-scripts");
+const nodes_1 = require("../../plugin/nodes");
+const versions_1 = require("../../utils/versions");
+const has_gradle_plugin_1 = require("../../utils/has-gradle-plugin");
+async function initGenerator(tree, options) {
+    const tasks = [];
+    if (!options.skipPackageJson && tree.exists('package.json')) {
+        tasks.push((0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+            '@nx/gradle': versions_1.nxVersion,
+        }, undefined, options.keepExistingVersions));
+    }
+    addPlugin(tree);
+    addProjectReportToBuildGradle(tree);
+    if (options.updatePackageScripts && tree.exists('package.json')) {
+        await (0, update_package_scripts_1.updatePackageScripts)(tree, nodes_1.createNodes);
+    }
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+exports.initGenerator = initGenerator;
+function addPlugin(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    if (!(0, has_gradle_plugin_1.hasGradlePlugin)(tree)) {
+        nxJson.plugins ??= [];
+        nxJson.plugins.push({
+            plugin: '@nx/gradle',
+            options: {
+                testTargetName: 'test',
+                classesTargetName: 'classes',
+                buildTargetName: 'build',
+            },
+        });
+        (0, devkit_1.updateNxJson)(tree, nxJson);
+    }
+}
+/**
+ * This function adds the project-report plugin to the build.gradle or build.gradle.kts file
+ */
+function addProjectReportToBuildGradle(tree) {
+    let buildGradleFile;
+    if (tree.exists('settings.gradle.kts')) {
+        buildGradleFile = 'build.gradle.kts';
+    }
+    else if (tree.exists('settings.gradle')) {
+        buildGradleFile = 'build.gradle';
+    }
+    else {
+        throw new Error('Could not find settings.gradle or settings.gradle.kts file in your gradle workspace.');
+    }
+    let buildGradleContent = '';
+    if (tree.exists(buildGradleFile)) {
+        buildGradleContent = tree.read(buildGradleFile).toString();
+    }
+    if (buildGradleContent.includes('allprojects')) {
+        if (!buildGradleContent.includes('"project-report')) {
+            devkit_1.logger.warn(`Please add the project-report plugin to your ${buildGradleFile}:
+allprojects {
+  apply {
+      plugin("project-report")
+  }
+}`);
+        }
+    }
+    else {
+        buildGradleContent += `\n\rallprojects {
+  apply {
+      plugin("project-report")
+  }
+}`;
+        tree.write(buildGradleFile, buildGradleContent);
+    }
+}
+exports.default = initGenerator;

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

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

package/src/generators/init/schema.json

@@ -0,0 +1,34 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxGradleInitSchema",
+  "title": "Gradle Init Generator",
+  "description": "Initializes a Gradle 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/src/plugin/dependencies.d.ts

@@ -0,0 +1,2 @@
+import { CreateDependencies } from '@nx/devkit';
+export declare const createDependencies: CreateDependencies;

package/src/plugin/dependencies.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDependencies = void 0;
+const devkit_1 = require("@nx/devkit");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const get_gradle_report_1 = require("../utils/get-gradle-report");
+const nodes_1 = require("./nodes");
+const createDependencies = async (_, context) => {
+    const gradleFiles = findGradleFiles(context.filesToProcess);
+    if (gradleFiles.length === 0) {
+        return [];
+    }
+    let dependencies = [];
+    const gradleDependenciesStart = performance.mark('gradleDependencies:start');
+    const { gradleFileToGradleProjectMap, gradleProjectToProjectName, buildFileToDepsMap, } = (0, get_gradle_report_1.getGradleReport)();
+    for (const gradleFile of gradleFiles) {
+        const gradleProject = gradleFileToGradleProjectMap.get(gradleFile);
+        const projectName = gradleProjectToProjectName.get(gradleProject);
+        const depsFile = buildFileToDepsMap.get(gradleFile);
+        if (projectName && depsFile) {
+            dependencies = dependencies.concat(Array.from(processGradleDependencies(depsFile, gradleProjectToProjectName, projectName, gradleFile, context)));
+        }
+    }
+    const gradleDependenciesEnd = performance.mark('gradleDependencies:end');
+    performance.measure('gradleDependencies', gradleDependenciesStart.name, gradleDependenciesEnd.name);
+    (0, nodes_1.writeTargetsToCache)(nodes_1.calculatedTargets);
+    if (dependencies.length) {
+        (0, get_gradle_report_1.invalidateGradleReportCache)();
+    }
+    return dependencies;
+};
+exports.createDependencies = createDependencies;
+const gradleConfigFileNames = new Set(['build.gradle', 'build.gradle.kts']);
+function findGradleFiles(fileMap) {
+    const gradleFiles = [];
+    for (const [_, files] of Object.entries(fileMap.projectFileMap)) {
+        for (const file of files) {
+            if (gradleConfigFileNames.has((0, node_path_1.basename)(file.file))) {
+                gradleFiles.push(file.file);
+            }
+        }
+    }
+    return gradleFiles;
+}
+function processGradleDependencies(depsFile, gradleProjectToProjectName, sourceProjectName, gradleFile, context) {
+    const dependencies = new Set();
+    const lines = (0, node_fs_1.readFileSync)(depsFile).toString().split('\n');
+    let inDeps = false;
+    for (const line of lines) {
+        if (line.startsWith('implementationDependenciesMetadata') ||
+            line.startsWith('compileClasspath')) {
+            inDeps = true;
+            continue;
+        }
+        if (inDeps) {
+            if (line === '') {
+                inDeps = false;
+                continue;
+            }
+            const [indents, dep] = line.split('--- ');
+            if ((indents === '\\' || indents === '+') && dep.startsWith('project ')) {
+                const gradleProjectName = dep
+                    .substring('project '.length)
+                    .replace(/ \(n\)$/, '')
+                    .trim();
+                const target = gradleProjectToProjectName.get(gradleProjectName);
+                const dependency = {
+                    source: sourceProjectName,
+                    target,
+                    type: devkit_1.DependencyType.static,
+                    sourceFile: gradleFile,
+                };
+                (0, devkit_1.validateDependency)(dependency, context);
+                dependencies.add(dependency);
+            }
+        }
+    }
+    return dependencies;
+}

package/src/plugin/nodes.d.ts

@@ -0,0 +1,16 @@
+import { CreateNodes, TargetConfiguration } from '@nx/devkit';
+export interface GradlePluginOptions {
+    testTargetName?: string;
+    classesTargetName?: string;
+    buildTargetName?: string;
+    [taskTargetName: string]: string | undefined;
+}
+export declare const calculatedTargets: Record<string, {
+    name: string;
+    targets: Record<string, TargetConfiguration>;
+}>;
+export declare function writeTargetsToCache(targets: Record<string, {
+    name: string;
+    targets: Record<string, TargetConfiguration>;
+}>): void;
+export declare const createNodes: CreateNodes<GradlePluginOptions>;

package/src/plugin/nodes.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodes = exports.writeTargetsToCache = exports.calculatedTargets = void 0;
+const devkit_1 = require("@nx/devkit");
+const calculate_hash_for_create_nodes_1 = require("@nx/devkit/src/utils/calculate-hash-for-create-nodes");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const cache_directory_1 = require("nx/src/utils/cache-directory");
+const exec_gradle_1 = require("../utils/exec-gradle");
+const get_gradle_report_1 = require("../utils/get-gradle-report");
+const nonCacheableGradleTaskTypes = new Set(['Application']);
+const dependsOnMap = {
+    build: ['^build', 'classes'],
+    test: ['classes'],
+    classes: ['^classes'],
+};
+const cachePath = (0, node_path_1.join)(cache_directory_1.projectGraphCacheDirectory, 'gradle.hash');
+const targetsCache = (0, node_fs_1.existsSync)(cachePath) ? readTargetsCache() : {};
+exports.calculatedTargets = {};
+function readTargetsCache() {
+    return (0, devkit_1.readJsonFile)(cachePath);
+}
+function writeTargetsToCache(targets) {
+    (0, devkit_1.writeJsonFile)(cachePath, targets);
+}
+exports.writeTargetsToCache = writeTargetsToCache;
+exports.createNodes = [
+    '**/build.{gradle.kts,gradle}',
+    (gradleFilePath, options, context) => {
+        const projectRoot = (0, node_path_1.dirname)(gradleFilePath);
+        const hash = (0, calculate_hash_for_create_nodes_1.calculateHashForCreateNodes)(projectRoot, options ?? {}, context);
+        if (targetsCache[hash]) {
+            exports.calculatedTargets[hash] = targetsCache[hash];
+            return {
+                projects: {
+                    [projectRoot]: targetsCache[hash],
+                },
+            };
+        }
+        try {
+            const { gradleProjectToTasksTypeMap, gradleFileToOutputDirsMap, gradleFileToGradleProjectMap, gradleProjectToProjectName, } = (0, get_gradle_report_1.getGradleReport)();
+            const gradleProject = gradleFileToGradleProjectMap.get(gradleFilePath);
+            const projectName = gradleProjectToProjectName.get(gradleProject);
+            if (!projectName) {
+                return;
+            }
+            const tasksTypeMap = gradleProjectToTasksTypeMap.get(gradleProject);
+            let tasks = [];
+            for (let [taskName, taskType] of tasksTypeMap.entries()) {
+                tasks.push({
+                    type: taskType,
+                    name: taskName,
+                });
+            }
+            const outputDirs = gradleFileToOutputDirsMap.get(gradleFilePath);
+            const targets = createGradleTargets(tasks, projectRoot, options, context, outputDirs);
+            exports.calculatedTargets[hash] = {
+                name: projectName,
+                targets,
+            };
+            return {
+                projects: {
+                    [projectRoot]: {
+                        root: projectRoot,
+                        name: projectName,
+                        targets,
+                    },
+                },
+            };
+        }
+        catch (e) {
+            console.error(e);
+            return {};
+        }
+    },
+];
+function createGradleTargets(tasks, projectRoot, options, context, outputDirs) {
+    const inputsMap = createInputsMap(context);
+    const targets = {};
+    for (const task of tasks) {
+        const targetName = options?.[`${task.name}TargetName`] ?? task.name;
+        const outputs = outputDirs.get(task.name);
+        targets[targetName] = {
+            command: `${(0, exec_gradle_1.getGradleBinaryPath)()} ${task.name}`,
+            options: {
+                cwd: projectRoot,
+            },
+            cache: !nonCacheableGradleTaskTypes.has(task.type),
+            inputs: inputsMap[task.name],
+            outputs: outputs ? [outputs] : undefined,
+            dependsOn: dependsOnMap[task.name],
+        };
+    }
+    return targets;
+}
+function createInputsMap(context) {
+    const namedInputs = context.nxJsonConfiguration.namedInputs;
+    return {
+        build: namedInputs?.production
+            ? ['production', '^production']
+            : ['default', '^default'],
+        test: ['default', namedInputs?.production ? '^production' : '^default'],
+        classes: ['default', '^default'],
+    };
+}

package/src/utils/exec-gradle.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ExecFileOptions } from 'child_process';
+import { ExecFileSyncOptionsWithBufferEncoding } from 'node:child_process';
+export declare function execGradle(args: string[], execOptions: ExecFileSyncOptionsWithBufferEncoding): Buffer;
+export declare function getGradleBinaryPath(): string;
+export declare function execGradleAsync(args: ReadonlyArray<string>, execOptions: ExecFileOptions): Promise<Buffer>;

package/src/utils/exec-gradle.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execGradleAsync = exports.getGradleBinaryPath = exports.execGradle = void 0;
+const devkit_1 = require("@nx/devkit");
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+function execGradle(args, execOptions) {
+    const gradleBinaryPath = getGradleBinaryPath();
+    return (0, node_child_process_1.execFileSync)(gradleBinaryPath, args, execOptions);
+}
+exports.execGradle = execGradle;
+function getGradleBinaryPath() {
+    const gradleFile = process.platform.startsWith('win')
+        ? 'gradlew.bat'
+        : 'gradlew';
+    const gradleBinaryPath = (0, node_path_1.join)(devkit_1.workspaceRoot, gradleFile);
+    if (!(0, node_fs_1.existsSync)(gradleBinaryPath)) {
+        throw new Error('Gradle is not setup. Run "gradle init"');
+    }
+    return gradleBinaryPath;
+}
+exports.getGradleBinaryPath = getGradleBinaryPath;
+function execGradleAsync(args, execOptions) {
+    const gradleBinaryPath = getGradleBinaryPath();
+    if (!(0, node_fs_1.existsSync)(gradleBinaryPath)) {
+        throw new Error('Gradle is not setup. Run "gradle init"');
+    }
+    return new Promise((res, rej) => {
+        const cp = (0, node_child_process_1.execFile)(gradleBinaryPath, args, execOptions);
+        let stdout = Buffer.from('');
+        cp.stdout?.on('data', (data) => {
+            stdout += data;
+        });
+        cp.on('exit', (code) => {
+            if (code === 0) {
+                res(stdout);
+            }
+            else {
+                rej(new Error(`Executing Gradle with ${args.join(' ')} failed with code: ${code}. \nLogs: ${stdout}`));
+            }
+        });
+    });
+}
+exports.execGradleAsync = execGradleAsync;

package/src/utils/get-gradle-report.d.ts

@@ -0,0 +1,10 @@
+interface GradleReport {
+    gradleFileToGradleProjectMap: Map<string, string>;
+    buildFileToDepsMap: Map<string, string>;
+    gradleFileToOutputDirsMap: Map<string, Map<string, string>>;
+    gradleProjectToTasksTypeMap: Map<string, Map<string, string>>;
+    gradleProjectToProjectName: Map<string, string>;
+}
+export declare function invalidateGradleReportCache(): void;
+export declare function getGradleReport(): GradleReport;
+export {};

package/src/utils/get-gradle-report.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGradleReport = exports.invalidateGradleReportCache = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const devkit_1 = require("@nx/devkit");
+const exec_gradle_1 = require("./exec-gradle");
+let gradleReportCache;
+function invalidateGradleReportCache() {
+    gradleReportCache = undefined;
+}
+exports.invalidateGradleReportCache = invalidateGradleReportCache;
+function getGradleReport() {
+    if (gradleReportCache) {
+        return gradleReportCache;
+    }
+    const gradleProjectReportStart = performance.mark('gradleProjectReport:start');
+    const projectReportLines = (0, exec_gradle_1.execGradle)(['projectReport'], {
+        cwd: devkit_1.workspaceRoot,
+    })
+        .toString()
+        .split('\n');
+    const gradleProjectReportEnd = performance.mark('gradleProjectReport:end');
+    performance.measure('gradleProjectReport', gradleProjectReportStart.name, gradleProjectReportEnd.name);
+    gradleReportCache = processProjectReports(projectReportLines);
+    return gradleReportCache;
+}
+exports.getGradleReport = getGradleReport;
+function processProjectReports(projectReportLines) {
+    /**
+     * Map of Gradle File path to Gradle Project Name
+     */
+    const gradleFileToGradleProjectMap = new Map();
+    /**
+     * Map of Gradle Project Name to Gradle File
+     */
+    const gradleProjectToGradleFileMap = new Map();
+    const dependenciesMap = new Map();
+    /**
+     * Map of Gradle Build File to tasks type map
+     */
+    const gradleProjectToTasksTypeMap = new Map();
+    const gradleProjectToProjectName = new Map();
+    /**
+     * Map of buildFile to dependencies report path
+     */
+    const buildFileToDepsMap = new Map();
+    /**
+     * Map fo possible output files of each gradle file
+     * e.g. {build.gradle.kts: { projectReportDir: '' testReportDir: '' }}
+     */
+    const gradleFileToOutputDirsMap = new Map();
+    projectReportLines.forEach((line, index) => {
+        if (line.startsWith('> Task ')) {
+            const nextLine = projectReportLines[index + 1];
+            if (line.endsWith(':dependencyReport')) {
+                const gradleProject = line.substring('> Task '.length, line.length - ':dependencyReport'.length);
+                const [_, file] = nextLine.split('file://');
+                dependenciesMap.set(gradleProject, file);
+            }
+            if (line.endsWith('propertyReport')) {
+                const gradleProject = line.substring('> Task '.length, line.length - ':propertyReport'.length);
+                const [_, file] = nextLine.split('file://');
+                const propertyReportLines = (0, node_fs_1.readFileSync)(file).toString().split('\n');
+                let projectName, absBuildFilePath, absBuildDirPath;
+                const outputDirMap = new Map();
+                for (const line of propertyReportLines) {
+                    if (line.startsWith('name: ')) {
+                        projectName = line.substring('name: '.length);
+                    }
+                    if (line.startsWith('buildFile: ')) {
+                        absBuildFilePath = line.substring('buildFile: '.length);
+                    }
+                    if (line.startsWith('buildDir: ')) {
+                        absBuildDirPath = line.substring('buildDir: '.length);
+                    }
+                    if (line.includes('Dir: ')) {
+                        const [dirName, dirPath] = line.split(': ');
+                        const taskName = dirName.replace('Dir', '');
+                        outputDirMap.set(taskName, `{workspaceRoot}/${(0, node_path_1.relative)(devkit_1.workspaceRoot, dirPath)}`);
+                    }
+                }
+                if (!projectName || !absBuildFilePath || !absBuildDirPath) {
+                    return;
+                }
+                const buildFile = (0, node_path_1.relative)(devkit_1.workspaceRoot, absBuildFilePath);
+                const buildDir = (0, node_path_1.relative)(devkit_1.workspaceRoot, absBuildDirPath);
+                buildFileToDepsMap.set(buildFile, dependenciesMap.get(gradleProject));
+                outputDirMap.set('build', `{workspaceRoot}/${buildDir}`);
+                outputDirMap.set('classes', `{workspaceRoot}/${(0, node_path_1.join)(buildDir, 'classes')}`);
+                gradleFileToOutputDirsMap.set(buildFile, outputDirMap);
+                gradleFileToGradleProjectMap.set(buildFile, gradleProject);
+                gradleProjectToGradleFileMap.set(gradleProject, buildFile);
+                gradleProjectToProjectName.set(gradleProject, projectName);
+            }
+            if (line.endsWith('taskReport')) {
+                const gradleProject = line.substring('> Task '.length, line.length - ':taskReport'.length);
+                const [_, file] = nextLine.split('file://');
+                const taskTypeMap = new Map();
+                const tasksFileLines = (0, node_fs_1.readFileSync)(file).toString().split('\n');
+                let i = 0;
+                while (i < tasksFileLines.length) {
+                    const line = tasksFileLines[i];
+                    if (line.endsWith('tasks')) {
+                        const dashes = new Array(line.length + 1).join('-');
+                        if (tasksFileLines[i + 1] === dashes) {
+                            const type = line.substring(0, line.length - ' tasks'.length);
+                            i++;
+                            while (tasksFileLines[++i] !== '') {
+                                const [taskName] = tasksFileLines[i].split(' - ');
+                                taskTypeMap.set(taskName, type);
+                            }
+                        }
+                    }
+                    i++;
+                }
+                gradleProjectToTasksTypeMap.set(gradleProject, taskTypeMap);
+            }
+        }
+    });
+    return {
+        gradleFileToGradleProjectMap,
+        buildFileToDepsMap,
+        gradleFileToOutputDirsMap,
+        gradleProjectToTasksTypeMap,
+        gradleProjectToProjectName,
+    };
+}

package/src/utils/has-gradle-plugin.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export declare function hasGradlePlugin(tree: Tree): boolean;

package/src/utils/has-gradle-plugin.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasGradlePlugin = void 0;
+const devkit_1 = require("@nx/devkit");
+function hasGradlePlugin(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    return !!nxJson.plugins?.some((p) => typeof p === 'string' ? p === '@nx/gradle' : p.plugin === '@nx/gradle');
+}
+exports.hasGradlePlugin = hasGradlePlugin;

package/src/utils/versions.d.ts

@@ -0,0 +1 @@
+export declare const nxVersion: any;

package/src/utils/versions.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nxVersion = void 0;
+exports.nxVersion = require('../../package.json').version;