@ohos-ports/nx 23.2.1-beta.0 → 23.3.0-beta.0

package/dist/src/command-line/init/implementation/angular/legacy-angular-versions.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLegacyMigrationFunctionIfApplicable = getLegacyMigrationFunctionIfApplicable;
+const child_process_1 = require("child_process");
+const path_1 = require("path");
+const semver_1 = require("semver");
+const fileutils_1 = require("../../../../utils/fileutils");
+const installation_directory_1 = require("../../../../utils/installation-directory");
+const object_sort_1 = require("../../../../utils/object-sort");
+const output_1 = require("../../../../utils/output");
+const package_json_1 = require("../../../../utils/package-json");
+const package_manager_1 = require("../../../../utils/package-manager");
+const connect_to_nx_cloud_1 = require("../../../nx-cloud/connect/connect-to-nx-cloud");
+const utils_1 = require("../utils");
+const format_1 = require("../format");
+// map of Angular major versions to Nx versions to use for legacy `nx init` migrations,
+// key is major Angular version and value is Nx version to use
+const nxAngularLegacyVersionMap = {
+    14: '~17.0.0',
+    15: '~19.0.0',
+    16: '~20.1.0',
+    17: '~21.1.0',
+    18: '~22.2.0',
+    19: '~23.0.0',
+};
+// min major angular version supported in latest Nx
+const minMajorAngularVersionSupported = Math.max(...Object.keys(nxAngularLegacyVersionMap).map(Number)) + 1;
+// version when the Nx CLI changed from @nrwl/tao & @nrwl/cli to nx
+const versionWithConsolidatedPackages = '13.9.0';
+// version when packages were rescoped from @nrwl/* to @nx/*
+const versionWithRescopeToNx = '16.0.0-beta.2';
+async function getLegacyMigrationFunctionIfApplicable(repoRoot, options) {
+    let majorAngularVersion;
+    try {
+        const angularVersion = (0, package_json_1.readModulePackageJson)('@angular/core', [
+            repoRoot,
+            ...(0, installation_directory_1.getNxRequirePaths)(),
+        ]).packageJson.version;
+        majorAngularVersion = (0, semver_1.major)(angularVersion);
+    }
+    catch {
+        output_1.output.error({
+            title: 'Could not determine the existing Angular version',
+            bodyLines: [
+                'Please ensure "@angular/core" is installed in the workspace and you are running this command from the root of the workspace.',
+            ],
+        });
+        // errors are caught in the initHandler and not logged to the user, so we
+        // log it first and then throw to ensure it is logged to the user
+        throw new Error('Could not determine the existing Angular version');
+    }
+    if (majorAngularVersion >= minMajorAngularVersionSupported) {
+        // non-legacy
+        return null;
+    }
+    let legacyMigrationCommand;
+    let pkgName;
+    let unscopedPkgName;
+    let pkgScope;
+    let pkgVersion;
+    if (majorAngularVersion < 13) {
+        // for versions lower than 13, the migration was in @nrwl/workspace:ng-add
+        pkgScope = '@nrwl';
+        unscopedPkgName = 'workspace';
+        pkgName = `${pkgScope}/${unscopedPkgName}`;
+        pkgVersion = await resolvePackageVersion(pkgName, `^${majorAngularVersion}.0.0`);
+        const preserveAngularCliLayoutFlag = !options.integrated
+            ? '--preserveAngularCLILayout'
+            : '--preserveAngularCLILayout=false';
+        legacyMigrationCommand = `ng g ${pkgName}:ng-add ${preserveAngularCliLayoutFlag}`;
+    }
+    else if (majorAngularVersion < 14) {
+        // for v13, the migration was in @nrwl/angular:ng-add
+        pkgScope = '@nrwl';
+        unscopedPkgName = 'angular';
+        pkgName = `${pkgScope}/${unscopedPkgName}`;
+        pkgVersion = await resolvePackageVersion(pkgName, '~14.1.0');
+        const preserveAngularCliLayoutFlag = !options.integrated
+            ? '--preserve-angular-cli-layout'
+            : '--preserve-angular-cli-layout=false';
+        legacyMigrationCommand = `ng g ${pkgName}:ng-add ${preserveAngularCliLayoutFlag}`;
+    }
+    else {
+        // use the latest Nx version that supported the Angular version
+        pkgVersion = await resolvePackageVersion('nx', nxAngularLegacyVersionMap[majorAngularVersion]);
+        pkgScope = (0, semver_1.gte)(pkgVersion, versionWithRescopeToNx) ? '@nx' : '@nrwl';
+        unscopedPkgName = 'angular';
+        pkgName = `${pkgScope}/${unscopedPkgName}`;
+        legacyMigrationCommand = `nx@${pkgVersion} init ${process.argv
+            .slice(2)
+            .join(' ')}`;
+    }
+    return async () => {
+        output_1.output.log({ title: '🐳 Nx initialization' });
+        const nxCloudChoice = options.nxCloud === true
+            ? 'yes'
+            : options.nxCloud === false
+                ? 'skip'
+                : options.interactive
+                    ? await (0, connect_to_nx_cloud_1.connectExistingRepoToNxCloudPrompt)()
+                    : 'skip';
+        output_1.output.log({ title: '📦 Installing dependencies' });
+        const pmc = (0, package_manager_1.getPackageManagerCommand)();
+        await installDependencies(repoRoot, {
+            pkgName,
+            pkgScope,
+            pkgVersion,
+            unscopedPkgName,
+        }, pmc);
+        output_1.output.log({ title: '📝 Setting up workspace' });
+        // Intentionally not runNxSync: legacyMigrationCommand is either the Angular
+        // CLI (`ng g ...:ng-add`) or a version-pinned `nx@<version> init`, neither
+        // of which is the local nx that runNxSync would resolve.
+        (0, child_process_1.execSync)(`${pmc.exec} ${legacyMigrationCommand}`, {
+            stdio: [0, 1, 2],
+            windowsHide: true,
+        });
+        if (nxCloudChoice === 'yes') {
+            output_1.output.log({ title: '🛠️ Setting up Nx Cloud' });
+            await (0, utils_1.initCloud)('nx-init-angular');
+        }
+    };
+}
+async function installDependencies(repoRoot, pkgInfo, pmc) {
+    const json = (0, fileutils_1.readJsonFile)((0, path_1.join)(repoRoot, 'package.json'));
+    json.devDependencies ??= {};
+    json.devDependencies[`${pkgInfo.pkgScope}/workspace`] = pkgInfo.pkgVersion;
+    if ((0, semver_1.gte)(pkgInfo.pkgVersion, versionWithConsolidatedPackages)) {
+        json.devDependencies['nx'] = pkgInfo.pkgVersion;
+    }
+    else {
+        json.devDependencies[`${pkgInfo.pkgScope}/cli`] = pkgInfo.pkgVersion;
+        json.devDependencies[`${pkgInfo.pkgScope}/tao`] = pkgInfo.pkgVersion;
+    }
+    json.devDependencies = (0, object_sort_1.sortObjectByKeys)(json.devDependencies);
+    if (pkgInfo.unscopedPkgName === 'angular') {
+        json.dependencies ??= {};
+        json.dependencies[pkgInfo.pkgName] = pkgInfo.pkgVersion;
+        json.dependencies = (0, object_sort_1.sortObjectByKeys)(json.dependencies);
+    }
+    (0, fileutils_1.writeJsonFile)(`package.json`, json);
+    (0, format_1.recordInitWrite)('package.json');
+    (0, child_process_1.execSync)(pmc.install, { stdio: [0, 1, 2], windowsHide: true });
+}
+async function resolvePackageVersion(packageName, version) {
+    try {
+        return await (0, package_manager_1.resolvePackageVersionUsingRegistry)(packageName, version);
+    }
+    catch {
+        return await (0, package_manager_1.resolvePackageVersionUsingInstallation)(packageName, version);
+    }
+}

package/dist/src/command-line/init/implementation/angular/standalone-workspace.d.ts

@@ -0,0 +1 @@
+export declare function setupStandaloneWorkspace(repoRoot: string, cacheableOperations: string[], workspaceTargets: string[]): Promise<void>;

package/dist/src/command-line/init/implementation/angular/standalone-workspace.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupStandaloneWorkspace = setupStandaloneWorkspace;
+const fs_1 = require("fs");
+const node_path_1 = require("node:path");
+const angular_json_1 = require("../../../../adapter/angular-json");
+const fileutils_1 = require("../../../../utils/fileutils");
+const path_1 = require("../../../../utils/path");
+const utils_1 = require("../utils");
+const format_1 = require("../format");
+async function setupStandaloneWorkspace(repoRoot, cacheableOperations, workspaceTargets) {
+    const angularJsonPath = (0, node_path_1.join)(repoRoot, 'angular.json');
+    const angularJson = (0, fileutils_1.readJsonFile)(angularJsonPath);
+    const workspaceCapabilities = getWorkspaceCapabilities(angularJson.projects);
+    createNxJson(repoRoot, angularJson, cacheableOperations, workspaceCapabilities, workspaceTargets);
+    (0, utils_1.addVsCodeRecommendedExtensions)(repoRoot, [
+        'nrwl.angular-console',
+        'angular.ng-template',
+        workspaceCapabilities.eslintProjectConfigFile
+            ? 'dbaeumer.vscode-eslint'
+            : undefined,
+    ].filter(Boolean));
+    replaceNgWithNxInPackageJsonScripts(repoRoot);
+    // convert workspace config format to standalone project configs
+    // update its targets outputs and delete angular.json
+    const projects = (0, angular_json_1.toNewFormat)(angularJson).projects;
+    for (const [projectName, project] of Object.entries(projects ?? {})) {
+        updateProjectOutputs(repoRoot, projectName, project, cacheableOperations);
+        const projectJsonPath = (0, node_path_1.join)(project.root, 'project.json');
+        (0, fileutils_1.writeJsonFile)(projectJsonPath, {
+            $schema: (0, path_1.normalizePath)((0, node_path_1.relative)((0, node_path_1.join)(repoRoot, project.root), (0, node_path_1.join)(repoRoot, 'node_modules/nx/schemas/project-schema.json'))),
+            name: projectName,
+            ...project,
+            root: undefined,
+        });
+        (0, format_1.recordInitWrite)(projectJsonPath);
+    }
+    (0, fs_1.unlinkSync)(angularJsonPath);
+}
+function createNxJson(repoRoot, angularJson, cacheableOperations, { eslintProjectConfigFile, test, karmaProjectConfigFile, }, workspaceTargets) {
+    (0, utils_1.createNxJsonFile)(repoRoot, [], cacheableOperations, {});
+    const nxJson = (0, fileutils_1.readJsonFile)((0, node_path_1.join)(repoRoot, 'nx.json'));
+    nxJson.namedInputs = {
+        sharedGlobals: [],
+        default: ['{projectRoot}/**/*', 'sharedGlobals'],
+        production: [
+            'default',
+            ...(test
+                ? [
+                    '!{projectRoot}/tsconfig.spec.json',
+                    '!{projectRoot}/**/*.spec.[jt]s',
+                    karmaProjectConfigFile ? '!{projectRoot}/karma.conf.js' : undefined,
+                ].filter(Boolean)
+                : []),
+            ...(eslintProjectConfigFile
+                ? ['!{projectRoot}/.eslintrc.json', '!{projectRoot}/eslint.config.cjs']
+                : []),
+        ].filter(Boolean),
+    };
+    const defaults = { ...(nxJson.targetDefaults ?? {}) };
+    if (workspaceTargets.includes('build')) {
+        (0, utils_1.upsertTargetDefaultEntry)(defaults, 'build', {
+            dependsOn: ['^build'],
+            inputs: ['production', '^production'],
+        });
+    }
+    if (workspaceTargets.includes('server')) {
+        (0, utils_1.upsertTargetDefaultEntry)(defaults, 'server', {
+            inputs: ['production', '^production'],
+        });
+    }
+    if (workspaceTargets.includes('test')) {
+        const inputs = ['default', '^production'];
+        if ((0, fileutils_1.fileExists)((0, node_path_1.join)(repoRoot, 'karma.conf.js'))) {
+            inputs.push('{workspaceRoot}/karma.conf.js');
+        }
+        (0, utils_1.upsertTargetDefaultEntry)(defaults, 'test', { inputs });
+    }
+    if (workspaceTargets.includes('lint')) {
+        const inputs = ['default'];
+        if ((0, fileutils_1.fileExists)((0, node_path_1.join)(repoRoot, '.eslintrc.json'))) {
+            inputs.push('{workspaceRoot}/.eslintrc.json');
+        }
+        if ((0, fileutils_1.fileExists)((0, node_path_1.join)(repoRoot, 'eslint.config.cjs'))) {
+            inputs.push('{workspaceRoot}/eslint.config.cjs');
+        }
+        (0, utils_1.upsertTargetDefaultEntry)(defaults, 'lint', { inputs });
+    }
+    if (workspaceTargets.includes('e2e')) {
+        (0, utils_1.upsertTargetDefaultEntry)(defaults, 'e2e', {
+            inputs: ['default', '^production'],
+        });
+    }
+    if (Object.keys(defaults).length > 0) {
+        nxJson.targetDefaults = defaults;
+    }
+    const nxJsonPath = (0, node_path_1.join)(repoRoot, 'nx.json');
+    (0, fileutils_1.writeJsonFile)(nxJsonPath, nxJson);
+    (0, format_1.recordInitWrite)(nxJsonPath);
+}
+function updateProjectOutputs(repoRoot, projectName, project, cacheableOperations) {
+    Object.entries(project.targets ?? {}).forEach(([targetName, target]) => {
+        if (target.executor === '@angular/build:application' ||
+            target.executor === '@angular-devkit/build-angular:application') {
+            if (target.options.outputPath) {
+                if (typeof target.options.outputPath === 'string') {
+                    target.outputs = ['{options.outputPath}'];
+                }
+                else if (target.options.outputPath.base) {
+                    target.outputs = ['{options.outputPath.base}'];
+                }
+                else if (cacheableOperations.includes(targetName)) {
+                    target.cache = false;
+                }
+            }
+            else {
+                target.options.outputPath = node_path_1.posix.join('dist', projectName);
+                target.outputs = ['{options.outputPath}'];
+            }
+        }
+        else if ([
+            '@angular-devkit/build-angular:browser-esbuild',
+            '@angular-devkit/build-angular:browser',
+            '@angular-builders/custom-webpack:browser',
+            'ngx-build-plus:browser',
+            '@angular-devkit/build-angular:server',
+            '@angular-builders/custom-webpack:server',
+            'ngx-build-plus:server',
+        ].includes(target.executor)) {
+            if (target.options.outputPath) {
+                target.outputs = ['{options.outputPath}'];
+            }
+            else if (cacheableOperations.includes(targetName)) {
+                target.cache = false;
+            }
+        }
+        else if (target.executor === '@angular-eslint/builder:lint') {
+            target.outputs = ['{options.outputFile}'];
+        }
+        else if (target.executor === '@angular-devkit/build-angular:ng-packagr' ||
+            target.executor === '@angular/build:ng-packagr') {
+            try {
+                const ngPackagrProject = target.options.project ?? node_path_1.posix.join(project.root, 'ng-package.json');
+                const ngPackageJsonPath = (0, node_path_1.join)(repoRoot, ngPackagrProject);
+                const ngPackageJson = (0, fileutils_1.readJsonFile)(ngPackageJsonPath);
+                const outputPath = (0, node_path_1.relative)(repoRoot, (0, node_path_1.resolve)((0, node_path_1.dirname)(ngPackageJsonPath), ngPackageJson.dest));
+                target.outputs = [`{workspaceRoot}/${(0, path_1.normalizePath)(outputPath)}`];
+            }
+            catch { }
+        }
+    });
+}
+function getWorkspaceCapabilities(projects) {
+    const capabilities = {
+        eslintProjectConfigFile: false,
+        test: false,
+        karmaProjectConfigFile: false,
+    };
+    for (const project of Object.values(projects ?? {})) {
+        if (!capabilities.eslintProjectConfigFile &&
+            projectHasEslintConfig(project)) {
+            capabilities.eslintProjectConfigFile = true;
+        }
+        if (!capabilities.test && projectUsesKarmaBuilder(project)) {
+            capabilities.test = true;
+        }
+        if (!capabilities.karmaProjectConfigFile &&
+            projectHasKarmaConfig(project)) {
+            capabilities.karmaProjectConfigFile = true;
+        }
+        if (capabilities.eslintProjectConfigFile &&
+            capabilities.test &&
+            capabilities.karmaProjectConfigFile) {
+            return capabilities;
+        }
+    }
+    return capabilities;
+}
+function projectUsesKarmaBuilder(project) {
+    return Object.values(project.architect ?? {}).some((target) => target.builder === '@angular/build:karma' ||
+        target.builder === '@angular-devkit/build-angular:karma');
+}
+function projectHasKarmaConfig(project) {
+    return (0, fileutils_1.fileExists)((0, node_path_1.join)(project.root, 'karma.conf.js'));
+}
+function projectHasEslintConfig(project) {
+    return ((0, fileutils_1.fileExists)((0, node_path_1.join)(project.root, '.eslintrc.json')) ||
+        (0, fileutils_1.fileExists)((0, node_path_1.join)(project.root, 'eslint.config.js')) ||
+        (0, fileutils_1.fileExists)((0, node_path_1.join)(project.root, 'eslint.config.mjs')) ||
+        (0, fileutils_1.fileExists)((0, node_path_1.join)(project.root, 'eslint.config.cjs')));
+}
+function replaceNgWithNxInPackageJsonScripts(repoRoot) {
+    const packageJsonPath = (0, node_path_1.join)(repoRoot, 'package.json');
+    const packageJson = (0, fileutils_1.readJsonFile)(packageJsonPath);
+    packageJson.scripts ??= {};
+    Object.keys(packageJson.scripts).forEach((script) => {
+        packageJson.scripts[script] = packageJson.scripts[script]
+            .replace(/^nx$/, 'nx')
+            .replace(/^ng /, 'nx ')
+            .replace(/ ng /g, ' nx ');
+    });
+    (0, fileutils_1.writeJsonFile)(packageJsonPath, packageJson);
+    (0, format_1.recordInitWrite)(packageJsonPath);
+}

package/dist/src/command-line/init/implementation/angular/types.d.ts

@@ -0,0 +1,20 @@
+import { InitArgs } from '../../init-v1';
+import type { TargetConfiguration } from '../../../../config/workspace-json-project-json';
+export type Options = Pick<InitArgs, 'nxCloud' | 'integrated' | 'interactive' | 'cacheable'>;
+export type AngularJsonConfigTargetConfiguration = Exclude<TargetConfiguration, 'command' | 'executor' | 'outputs' | 'dependsOn' | 'inputs'> & {
+    builder: string;
+};
+export type AngularJsonProjectConfiguration = {
+    root: string;
+    sourceRoot: string;
+    architect?: Record<string, AngularJsonConfigTargetConfiguration>;
+};
+export interface AngularJsonConfig {
+    projects: Record<string, AngularJsonProjectConfiguration>;
+    defaultProject?: string;
+}
+export type WorkspaceCapabilities = {
+    eslintProjectConfigFile: boolean;
+    test: boolean;
+    karmaProjectConfigFile: boolean;
+};

package/dist/src/command-line/init/implementation/angular/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/command-line/init/implementation/check-compatible-with-plugins.d.ts

@@ -0,0 +1,15 @@
+export interface IncompatibleFiles {
+    [pluginIndex: number]: {
+        file: string;
+        error?: any;
+    }[];
+}
+/**
+ * This function checks if the imported project is compatible with the plugins.
+ * @returns a map of plugin names to files that are incompatible with the plugins
+ */
+export declare function checkCompatibleWithPlugins(): Promise<IncompatibleFiles>;
+/**
+ * This function updates the plugins in the nx.json file with the given plugin names and files to exclude.
+ */
+export declare function updatePluginsInNxJson(root: string, pluginToExcludeFiles: IncompatibleFiles): void;

package/dist/src/command-line/init/implementation/check-compatible-with-plugins.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkCompatibleWithPlugins = checkCompatibleWithPlugins;
+exports.updatePluginsInNxJson = updatePluginsInNxJson;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const picocolors_1 = require("picocolors");
+const error_types_1 = require("../../../project-graph/error-types");
+const workspace_root_1 = require("../../../utils/workspace-root");
+const fileutils_1 = require("../../../utils/fileutils");
+const format_1 = require("./format");
+const output_1 = require("../../../utils/output");
+const project_graph_1 = require("../../../project-graph/project-graph");
+/**
+ * This function checks if the imported project is compatible with the plugins.
+ * @returns a map of plugin names to files that are incompatible with the plugins
+ */
+async function checkCompatibleWithPlugins() {
+    let pluginToExcludeFiles = {};
+    try {
+        await (0, project_graph_1.createProjectGraphAsync)();
+    }
+    catch (projectGraphError) {
+        if (projectGraphError instanceof error_types_1.ProjectGraphError) {
+            projectGraphError.getErrors()?.forEach((error) => {
+                const { pluginIndex, excludeFiles } = findPluginAndFilesWithError(error) ?? {};
+                if (pluginIndex !== undefined && excludeFiles?.length) {
+                    pluginToExcludeFiles[pluginIndex] ??= [];
+                    pluginToExcludeFiles[pluginIndex].push(...excludeFiles);
+                }
+                else if (!(0, error_types_1.isProjectsWithNoNameError)(error)) {
+                    // print error if it is not ProjectsWithNoNameError and unable to exclude files
+                    output_1.output.error({
+                        title: error.message,
+                        bodyLines: error.stack?.split('\n'),
+                    });
+                }
+            });
+        }
+        else {
+            output_1.output.error({
+                title: 'Failed to process project graph. Run "nx reset" to fix this. Please report the issue if you keep seeing it.',
+                bodyLines: projectGraphError.stack?.split('\n'),
+            });
+        }
+    }
+    return pluginToExcludeFiles;
+}
+/**
+ * This function finds the plugin name and files that caused the error.
+ * @param error the error to find the plugin name and files for
+ * @returns pluginName and excludeFiles if found, otherwise undefined
+ */
+function findPluginAndFilesWithError(error) {
+    let pluginIndex;
+    let excludeFiles = [];
+    if ((0, error_types_1.isAggregateCreateNodesError)(error)) {
+        pluginIndex = error.pluginIndex;
+        excludeFiles =
+            error.errors?.map((error) => {
+                return {
+                    file: error?.[0],
+                    error: error?.[1],
+                };
+            }) ?? [];
+    }
+    else if ((0, error_types_1.isMergeNodesError)(error)) {
+        pluginIndex = error.pluginIndex;
+        excludeFiles = [
+            {
+                file: error.file,
+                error: error,
+            },
+        ];
+    }
+    excludeFiles = excludeFiles.filter(Boolean).map((excludeFile) => {
+        const file = excludeFile.file;
+        excludeFile.file = file.startsWith(workspace_root_1.workspaceRoot)
+            ? (0, node_path_1.relative)(workspace_root_1.workspaceRoot, file)
+            : file;
+        return excludeFile;
+    });
+    return {
+        pluginIndex,
+        excludeFiles,
+    };
+}
+/**
+ * This function updates the plugins in the nx.json file with the given plugin names and files to exclude.
+ */
+function updatePluginsInNxJson(root = workspace_root_1.workspaceRoot, pluginToExcludeFiles) {
+    const nxJsonPath = (0, node_path_1.join)(root, 'nx.json');
+    if (!(0, node_fs_1.existsSync)(nxJsonPath)) {
+        return;
+    }
+    let nxJson;
+    try {
+        nxJson = (0, fileutils_1.readJsonFile)(nxJsonPath);
+    }
+    catch {
+        // If there is an error reading the nx.json file, no need to update it
+        return;
+    }
+    if (!Object.keys(pluginToExcludeFiles)?.length || !nxJson?.plugins?.length) {
+        return;
+    }
+    Object.entries(pluginToExcludeFiles).forEach(([pluginIndex, excludeFiles]) => {
+        let plugin = nxJson.plugins[pluginIndex];
+        if (!plugin || excludeFiles.length === 0) {
+            return;
+        }
+        if (typeof plugin === 'string') {
+            plugin = { plugin };
+        }
+        output_1.output.warn({
+            title: `The following files were incompatible with ${plugin.plugin} and has been excluded for now:`,
+            bodyLines: excludeFiles
+                .map((file) => {
+                const output = [`  - ${(0, picocolors_1.bold)(file.file)}`];
+                if (file.error?.message) {
+                    output.push(`    ${file.error.message}`);
+                }
+                return output;
+            })
+                .flat(),
+        });
+        const excludes = new Set(plugin.exclude ?? []);
+        excludeFiles.forEach((file) => {
+            excludes.add(file.file);
+        });
+        plugin.exclude = Array.from(excludes);
+        nxJson.plugins[pluginIndex] = plugin;
+    });
+    (0, fileutils_1.writeJsonFile)(nxJsonPath, nxJson);
+    (0, format_1.recordInitWrite)(nxJsonPath);
+}

package/dist/src/command-line/init/implementation/deduce-default-base.d.ts

@@ -0,0 +1 @@
+export declare function deduceDefaultBase(): string;

package/dist/src/command-line/init/implementation/deduce-default-base.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deduceDefaultBase = deduceDefaultBase;
+const node_child_process_1 = require("node:child_process");
+const default_base_1 = require("../../../utils/default-base");
+function deduceDefaultBase() {
+    try {
+        (0, node_child_process_1.execSync)(`git rev-parse --verify main`, {
+            stdio: ['ignore', 'ignore', 'ignore'],
+            windowsHide: true,
+        });
+        return 'main';
+    }
+    catch {
+        try {
+            (0, node_child_process_1.execSync)(`git rev-parse --verify dev`, {
+                stdio: ['ignore', 'ignore', 'ignore'],
+                windowsHide: true,
+            });
+            return 'dev';
+        }
+        catch {
+            try {
+                (0, node_child_process_1.execSync)(`git rev-parse --verify develop`, {
+                    stdio: ['ignore', 'ignore', 'ignore'],
+                    windowsHide: true,
+                });
+                return 'develop';
+            }
+            catch {
+                try {
+                    (0, node_child_process_1.execSync)(`git rev-parse --verify next`, {
+                        stdio: ['ignore', 'ignore', 'ignore'],
+                        windowsHide: true,
+                    });
+                    return 'next';
+                }
+                catch {
+                    try {
+                        (0, node_child_process_1.execSync)(`git rev-parse --verify master`, {
+                            stdio: ['ignore', 'ignore', 'ignore'],
+                            windowsHide: true,
+                        });
+                        return 'master';
+                    }
+                    catch {
+                        return (0, default_base_1.deduceDefaultBase)();
+                    }
+                }
+            }
+        }
+    }
+}

package/dist/src/command-line/init/implementation/dot-nx/add-nx-scripts.d.ts

@@ -0,0 +1,11 @@
+import { Tree } from '../../../../generators/tree';
+export declare const nxWrapperPath: (p?: typeof import('path')) => string;
+export declare function getDotNxWrapperVersionCommand(platform?: NodeJS.Platform): string;
+export declare function generateDotNxSetup(version?: string): void;
+export declare function normalizeVersionForNxJson(pkg: string, version: string): string;
+export declare function writeMinimalNxJson(host: Tree, version: string): void;
+export declare function updateGitIgnore(host: Tree): void;
+export declare function getNxWrapperContents(): string;
+export declare function getShellScriptContents(): string;
+export declare function getBatchScriptContents(): string;
+export declare function sanitizeWrapperScript(input: string): string;