@ohos-ports/nx 19.8.4-beta.0

package/src/command-line/init/implementation/angular/index.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addNxToAngularCliRepo = addNxToAngularCliRepo;
+const enquirer_1 = require("enquirer");
+const path_1 = require("path");
+const fileutils_1 = require("../../../../utils/fileutils");
+const versions_1 = require("../../../../utils/versions");
+const object_sort_1 = require("../../../../utils/object-sort");
+const output_1 = require("../../../../utils/output");
+const utils_1 = require("../utils");
+const integrated_workspace_1 = require("./integrated-workspace");
+const legacy_angular_versions_1 = require("./legacy-angular-versions");
+const standalone_workspace_1 = require("./standalone-workspace");
+const connect_to_nx_cloud_1 = require("../../../connect/connect-to-nx-cloud");
+const defaultCacheableOperations = [
+    'build',
+    'server',
+    'test',
+    'lint',
+];
+let repoRoot;
+let workspaceTargets;
+async function addNxToAngularCliRepo(options) {
+    repoRoot = process.cwd();
+    output_1.output.log({ title: '🧐 Checking versions compatibility' });
+    const legacyMigrationFn = await (0, legacy_angular_versions_1.getLegacyMigrationFunctionIfApplicable)(repoRoot, options);
+    if (legacyMigrationFn) {
+        output_1.output.log({ title: '💽 Running migration for a legacy Angular version' });
+        await legacyMigrationFn();
+        process.exit(0);
+    }
+    output_1.output.success({
+        title: '✅ The Angular version is compatible with the latest version of Nx!',
+    });
+    output_1.output.log({ title: '🐳 Nx initialization' });
+    const cacheableOperations = !options.integrated
+        ? await collectCacheableOperations(options)
+        : [];
+    const useNxCloud = options.nxCloud ??
+        (options.interactive ? await (0, connect_to_nx_cloud_1.connectExistingRepoToNxCloudPrompt)() : false);
+    output_1.output.log({ title: '📦 Installing dependencies' });
+    installDependencies();
+    output_1.output.log({ title: '📝 Setting up workspace' });
+    await setupWorkspace(cacheableOperations, options.integrated);
+    if (useNxCloud) {
+        output_1.output.log({ title: '🛠️ Setting up Nx Cloud' });
+        await (0, utils_1.initCloud)('nx-init-angular');
+    }
+}
+async function collectCacheableOperations(options) {
+    let cacheableOperations;
+    workspaceTargets = getWorkspaceTargets();
+    const defaultCacheableTargetsInWorkspace = defaultCacheableOperations.filter((t) => workspaceTargets.includes(t));
+    if (options.interactive && workspaceTargets.length > 0) {
+        output_1.output.log({
+            title: '🧑‍🔧 Please answer the following questions about the targets found in your angular.json in order to generate task runner configuration',
+        });
+        cacheableOperations = (await (0, enquirer_1.prompt)([
+            {
+                type: 'multiselect',
+                name: 'cacheableOperations',
+                initial: defaultCacheableTargetsInWorkspace,
+                message: 'Which of the following targets are cacheable? (Produce the same output given the same input, e.g. build, test and lint usually are, serve and start are not)',
+                // enquirer mutates the array below, create a new one to avoid it
+                choices: [...workspaceTargets],
+                /**
+                 * limit is missing from the interface but it limits the amount of options shown
+                 */
+                limit: process.stdout.rows - 4, // 4 leaves room for the header above, the prompt and some whitespace
+            },
+        ])).cacheableOperations;
+    }
+    else {
+        cacheableOperations =
+            options.cacheable ?? defaultCacheableTargetsInWorkspace;
+    }
+    return cacheableOperations;
+}
+function installDependencies() {
+    (0, utils_1.addDepsToPackageJson)(repoRoot);
+    addPluginDependencies();
+    (0, utils_1.runInstall)(repoRoot);
+}
+function addPluginDependencies() {
+    const packageJsonPath = (0, path_1.join)(repoRoot, 'package.json');
+    const packageJson = (0, fileutils_1.readJsonFile)(packageJsonPath);
+    packageJson.devDependencies ??= {};
+    packageJson.devDependencies['@nx/angular'] = versions_1.nxVersion;
+    packageJson.devDependencies['@nx/workspace'] = versions_1.nxVersion;
+    const peerDepsToInstall = [
+        '@angular-devkit/core',
+        '@angular-devkit/schematics',
+        '@schematics/angular',
+    ];
+    const angularCliVersion = packageJson.devDependencies['@angular/cli'] ??
+        packageJson.dependencies?.['@angular/cli'] ??
+        packageJson.devDependencies['@angular-devkit/build-angular'] ??
+        packageJson.dependencies?.['@angular-devkit/build-angular'];
+    for (const dep of peerDepsToInstall) {
+        if (!packageJson.devDependencies[dep] && !packageJson.dependencies?.[dep]) {
+            packageJson.devDependencies[dep] = angularCliVersion;
+        }
+    }
+    packageJson.devDependencies = (0, object_sort_1.sortObjectByKeys)(packageJson.devDependencies);
+    (0, fileutils_1.writeJsonFile)(packageJsonPath, packageJson);
+}
+async function setupWorkspace(cacheableOperations, isIntegratedMigration) {
+    (0, utils_1.updateGitIgnore)(repoRoot);
+    if (isIntegratedMigration) {
+        (0, integrated_workspace_1.setupIntegratedWorkspace)();
+    }
+    else {
+        await (0, standalone_workspace_1.setupStandaloneWorkspace)(repoRoot, cacheableOperations, workspaceTargets);
+    }
+}
+function getWorkspaceTargets() {
+    const { projects } = (0, fileutils_1.readJsonFile)((0, path_1.join)(repoRoot, 'angular.json'));
+    const targets = new Set();
+    for (const project of Object.values(projects ?? {})) {
+        for (const target of Object.keys(project.architect ?? {})) {
+            targets.add(target);
+        }
+    }
+    return Array.from(targets);
+}

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

@@ -0,0 +1 @@
+export declare function setupIntegratedWorkspace(): void;

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupIntegratedWorkspace = setupIntegratedWorkspace;
+const child_process_1 = require("child_process");
+const package_manager_1 = require("../../../../utils/package-manager");
+function setupIntegratedWorkspace() {
+    const pmc = (0, package_manager_1.getPackageManagerCommand)();
+    (0, child_process_1.execSync)(`${pmc.exec} nx g @nx/angular:ng-add`, {
+        stdio: [0, 1, 2],
+        windowsHide: true,
+    });
+}

package/src/command-line/init/implementation/angular/legacy-angular-versions.d.ts

@@ -0,0 +1,2 @@
+import type { Options } from './types';
+export declare function getLegacyMigrationFunctionIfApplicable(repoRoot: string, options: Options): Promise<() => Promise<void> | null>;

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

@@ -0,0 +1,122 @@
+"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 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 utils_1 = require("../utils");
+const connect_to_nx_cloud_1 = require("../../../connect/connect-to-nx-cloud");
+// 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',
+};
+// min major angular version supported in latest Nx
+const minMajorAngularVersionSupported = 16;
+// 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) {
+    const angularVersion = (0, package_json_1.readModulePackageJson)('@angular/core').packageJson.version;
+    const majorAngularVersion = (0, semver_1.major)(angularVersion);
+    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 useNxCloud = options.nxCloud ??
+            (options.interactive
+                ? await (0, connect_to_nx_cloud_1.connectExistingRepoToNxCloudPrompt)()
+                : false);
+        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' });
+        (0, child_process_1.execSync)(`${pmc.exec} ${legacyMigrationCommand}`, {
+            stdio: [0, 1, 2],
+            windowsHide: true,
+        });
+        if (useNxCloud) {
+            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, 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/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/src/command-line/init/implementation/angular/standalone-workspace.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupStandaloneWorkspace = setupStandaloneWorkspace;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const angular_json_1 = require("../../../../adapter/angular-json");
+const fileutils_1 = require("../../../../utils/fileutils");
+const path_2 = require("../../../../utils/path");
+const utils_1 = require("../utils");
+async function setupStandaloneWorkspace(repoRoot, cacheableOperations, workspaceTargets) {
+    const angularJsonPath = (0, 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, project);
+        (0, fileutils_1.writeJsonFile)((0, path_1.join)(project.root, 'project.json'), {
+            $schema: (0, path_2.normalizePath)((0, path_1.relative)((0, path_1.join)(repoRoot, project.root), (0, path_1.join)(repoRoot, 'node_modules/nx/schemas/project-schema.json'))),
+            name: projectName,
+            ...project,
+            root: undefined,
+        });
+    }
+    (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, 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.js']
+                : []),
+        ].filter(Boolean),
+    };
+    nxJson.targetDefaults ??= {};
+    if (workspaceTargets.includes('build')) {
+        nxJson.targetDefaults.build = {
+            ...nxJson.targetDefaults.build,
+            dependsOn: ['^build'],
+            inputs: ['production', '^production'],
+        };
+    }
+    if (workspaceTargets.includes('server')) {
+        nxJson.targetDefaults.server = {
+            ...nxJson.targetDefaults.server,
+            inputs: ['production', '^production'],
+        };
+    }
+    if (workspaceTargets.includes('test')) {
+        const inputs = ['default', '^production'];
+        if ((0, fileutils_1.fileExists)((0, path_1.join)(repoRoot, 'karma.conf.js'))) {
+            inputs.push('{workspaceRoot}/karma.conf.js');
+        }
+        nxJson.targetDefaults.test = {
+            ...nxJson.targetDefaults.test,
+            inputs,
+        };
+    }
+    if (workspaceTargets.includes('lint')) {
+        const inputs = ['default'];
+        if ((0, fileutils_1.fileExists)((0, path_1.join)(repoRoot, '.eslintrc.json'))) {
+            inputs.push('{workspaceRoot}/.eslintrc.json');
+        }
+        if ((0, fileutils_1.fileExists)((0, path_1.join)(repoRoot, 'eslint.config.js'))) {
+            inputs.push('{workspaceRoot}/eslint.config.js');
+        }
+        nxJson.targetDefaults.lint = {
+            ...nxJson.targetDefaults.lint,
+            inputs,
+        };
+    }
+    if (workspaceTargets.includes('e2e')) {
+        nxJson.targetDefaults.e2e = {
+            ...nxJson.targetDefaults.e2e,
+            inputs: ['default', '^production'],
+        };
+    }
+    (0, fileutils_1.writeJsonFile)((0, path_1.join)(repoRoot, 'nx.json'), nxJson);
+}
+function updateProjectOutputs(repoRoot, project) {
+    Object.values(project.targets ?? {}).forEach((target) => {
+        if ([
+            '@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)) {
+            target.outputs = ['{options.outputPath}'];
+        }
+        else if (target.executor === '@angular-eslint/builder:lint') {
+            target.outputs = ['{options.outputFile}'];
+        }
+        else if (target.executor === '@angular-devkit/build-angular:ng-packagr') {
+            try {
+                const ngPackageJsonPath = (0, path_1.join)(repoRoot, target.options.project);
+                const ngPackageJson = (0, fileutils_1.readJsonFile)(ngPackageJsonPath);
+                const outputPath = (0, path_1.relative)(repoRoot, (0, path_1.resolve)((0, path_1.dirname)(ngPackageJsonPath), ngPackageJson.dest));
+                target.outputs = [`{workspaceRoot}/${(0, path_2.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-devkit/build-angular:karma');
+}
+function projectHasKarmaConfig(project) {
+    return (0, fileutils_1.fileExists)((0, path_1.join)(project.root, 'karma.conf.js'));
+}
+function projectHasEslintConfig(project) {
+    return ((0, fileutils_1.fileExists)((0, path_1.join)(project.root, '.eslintrc.json')) ||
+        (0, fileutils_1.fileExists)((0, path_1.join)(project.root, 'eslint.config.js')));
+}
+function replaceNgWithNxInPackageJsonScripts(repoRoot) {
+    const packageJsonPath = (0, 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);
+}

package/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/src/command-line/init/implementation/angular/types.js

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

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

@@ -0,0 +1,8 @@
+import { Tree } from '../../../../generators/tree';
+export declare const nxWrapperPath: (p?: typeof import("path")) => 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 sanitizeWrapperScript(input: string): string;

package/src/command-line/init/implementation/dot-nx/add-nx-scripts.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nxWrapperPath = void 0;
+exports.generateDotNxSetup = generateDotNxSetup;
+exports.normalizeVersionForNxJson = normalizeVersionForNxJson;
+exports.writeMinimalNxJson = writeMinimalNxJson;
+exports.updateGitIgnore = updateGitIgnore;
+exports.getNxWrapperContents = getNxWrapperContents;
+exports.sanitizeWrapperScript = sanitizeWrapperScript;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path = require("path");
+const semver_1 = require("semver");
+const tree_1 = require("../../../../generators/tree");
+const json_1 = require("../../../../generators/utils/json");
+const nxWrapperPath = (p = path) => p.join('.nx', 'nxw.js');
+exports.nxWrapperPath = nxWrapperPath;
+const NODE_MISSING_ERR = 'Nx requires NodeJS to be available. To install NodeJS and NPM, see: https://nodejs.org/en/download/ .';
+const NPM_MISSING_ERR = 'Nx requires npm to be available. To install NodeJS and NPM, see: https://nodejs.org/en/download/ .';
+const BATCH_SCRIPT_CONTENTS = [
+    // don't log command to console
+    `@ECHO OFF`,
+    // Prevents path_to_root from being inherited by child processes
+    `SETLOCAL`,
+    `SET path_to_root=%~dp0`,
+    // Checks if node is available
+    `WHERE node >nul 2>nul`,
+    `IF %ERRORLEVEL% NEQ 0 (ECHO ${NODE_MISSING_ERR} & GOTO exit)`,
+    // Checks if npm is available
+    `WHERE npm >nul 2>nul`,
+    `IF %ERRORLEVEL% NEQ 0 (ECHO ${NPM_MISSING_ERR} & GOTO exit)`,
+    // Executes the nx wrapper script
+    `node ${path.win32.join('%path_to_root%', (0, exports.nxWrapperPath)(path.win32))} %*`,
+    // Exits with the same error code as the previous command
+    `:exit`,
+    `  cmd /c exit /b %ERRORLEVEL%`,
+].join('\r\n');
+const SHELL_SCRIPT_CONTENTS = [
+    // Execute in bash
+    `#!/bin/bash`,
+    // Checks if node is available
+    `command -v node >/dev/null 2>&1 || { echo >&2 "${NODE_MISSING_ERR}"; exit 1; }`,
+    // Checks if npm is available
+    `command -v npm >/dev/null 2>&1 || { echo >&2 "${NPM_MISSING_ERR}"; exit 1; }`,
+    // Gets the path to the root of the project
+    `path_to_root=$(dirname $BASH_SOURCE)`,
+    // Executes the nx wrapper script
+    `node ${path.posix.join('$path_to_root', (0, exports.nxWrapperPath)(path.posix))} $@`,
+].join('\n');
+function generateDotNxSetup(version) {
+    const host = new tree_1.FsTree(process.cwd(), false, '.nx setup');
+    writeMinimalNxJson(host, version);
+    updateGitIgnore(host);
+    host.write((0, exports.nxWrapperPath)(), getNxWrapperContents());
+    host.write('nx.bat', BATCH_SCRIPT_CONTENTS);
+    host.write('nx', SHELL_SCRIPT_CONTENTS, {
+        mode: fs_1.constants.S_IXUSR | fs_1.constants.S_IRUSR | fs_1.constants.S_IWUSR,
+    });
+    const changes = host.listChanges();
+    (0, tree_1.printChanges)(changes);
+    (0, tree_1.flushChanges)(host.root, changes);
+}
+function normalizeVersionForNxJson(pkg, version) {
+    if (!(0, semver_1.valid)(version)) {
+        version = (0, child_process_1.execSync)(`npm view ${pkg}@${version} version`, {
+            windowsHide: true,
+        }).toString();
+    }
+    return version.trimEnd();
+}
+function writeMinimalNxJson(host, version) {
+    if (!host.exists('nx.json')) {
+        (0, json_1.writeJson)(host, 'nx.json', {
+            installation: {
+                version: normalizeVersionForNxJson('nx', version),
+            },
+        });
+    }
+}
+function updateGitIgnore(host) {
+    let contents = host.read('.gitignore', 'utf-8') ?? '';
+    ['.nx/installation', '.nx/cache', '.nx/workspace-data'].forEach((file) => {
+        if (!contents.includes(file)) {
+            contents = [contents, file].join('\n');
+        }
+    });
+    host.write('.gitignore', contents);
+}
+// Gets the sanitized contents for nxw.js
+function getNxWrapperContents() {
+    return sanitizeWrapperScript((0, fs_1.readFileSync)(path.join(__dirname, 'nxw.js'), 'utf-8'));
+}
+// Remove any empty comments or comments that start with `//#: ` or eslint-disable comments.
+// This removes the sourceMapUrl since it is invalid, as well as any internal comments.
+function sanitizeWrapperScript(input) {
+    const linesToRemove = [
+        // Comments that start with //#
+        '\\/\\/# .*',
+        // Comments that are empty (often used for newlines between internal comments)
+        '\\s*\\/\\/\\s*',
+        // Comments that disable an eslint rule.
+        '\\/\\/ eslint-disable-next-line.*',
+    ];
+    const regex = `(${linesToRemove.join('|')})$`;
+    return input.replace(new RegExp(regex, 'gm'), '');
+}

package/src/command-line/init/implementation/dot-nx/nxw.d.ts

@@ -0,0 +1 @@
+export {};