@mouryaamit/nx-polystack 0.0.0-stage → 1.0.0

package/dist/src/generators/migrate/adapters/nx-workspace.js

@@ -0,0 +1,1037 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rewriteScript = exports.nxWorkspaceAdapter = exports.classifyWorkspaceSpec = exports.dependencyFields = exports.treeProjectNames = exports.planNxImport = exports.workspacePaths = void 0;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+const devkit_1 = require("@nx/devkit");
+const angular_deps_1 = require("../../../lib/utils/angular-deps");
+const csp_nonce_1 = require("../../../lib/utils/csp-nonce");
+const dependencies_1 = require("../../../lib/utils/dependencies");
+const env_files_1 = require("../../../lib/utils/env-files");
+const node_engine_1 = require("../../../lib/utils/node-engine");
+const npm_scripts_1 = require("../../../lib/utils/npm-scripts");
+const serve_port_1 = require("../../../lib/utils/serve-port");
+const generator_1 = require("../../app/generator");
+const angular_project_json_1 = require("../angular-project-json");
+const copy_1 = require("../copy");
+const dependencies_2 = require("../dependencies");
+const packages_1 = require("../ionic/packages");
+const shape_1 = require("../ionic/shape");
+const skip_1 = require("../ionic/skip");
+const npm_deps_1 = require("../npm-deps");
+const build_scripts_1 = require("../nx/build-scripts");
+const detect_1 = require("../nx/detect");
+const env_encryption_1 = require("../nx/env-encryption");
+const rewrite_1 = require("../nx/rewrite");
+const selection_1 = require("../nx/selection");
+const shared_folders_1 = require("../nx/shared-folders");
+const workspace_source_1 = require("../nx/workspace-source");
+const pnpm_1 = require("../pnpm");
+const source_1 = require("../source");
+const angular_cli_1 = require("./angular-cli");
+const flutter_1 = require("./flutter");
+const types_1 = require("./types");
+const code = (s) => `\`${s}\``;
+/** Kinds whose packages come from the source's root package.json. */
+const NPM_KINDS = new Set(['angular-app', 'ionic-app', 'lib']);
+const normalizePath = (p) => path.posix.normalize(p).replace(/^\.\//, '');
+function workspacePaths(tree) {
+    if (!tree.exists('tsconfig.base.json'))
+        return {};
+    const paths = (0, devkit_1.readJson)(tree, 'tsconfig.base.json')?.compilerOptions?.paths;
+    if (!(0, workspace_source_1.isObject)(paths))
+        return {};
+    return Object.fromEntries(Object.entries(paths).map(([alias, targets]) => [
+        alias,
+        Array.isArray(targets) ? targets.map((t) => normalizePath(String(t))) : [],
+    ]));
+}
+exports.workspacePaths = workspacePaths;
+/** Selection, names and every check; throws (writing nothing) when something is in the way. */
+function planNxImport(tree, ctx) {
+    const all = (0, workspace_source_1.discoverProjects)(ctx.sourceDir);
+    const chosen = (0, selection_1.selectProjects)({
+        sourceDir: ctx.sourceDir,
+        projects: all,
+        requested: ctx.projects,
+        noDeps: ctx.noDeps,
+    });
+    const renames = new Map([...chosen.keys()].map((n) => [n, ctx.prefix ? `${ctx.prefix}-${n}` : n]));
+    const byName = new Map(all.map((p) => [p.name, p]));
+    const projects = [...chosen]
+        .map(([n, neededBy]) => {
+        const source = byName.get(n);
+        if (!source)
+            throw new Error(`migrate: unknown source project "${n}".`);
+        return { source, name: renames.get(n) ?? n, neededBy };
+    })
+        .sort((a, b) => (a.source.root < b.source.root ? -1 : 1));
+    const copied = projects.map((p) => p.source);
+    const copiedAliases = {};
+    const otherAliases = [];
+    for (const [alias, targets] of Object.entries((0, selection_1.readSourceAliases)(ctx.sourceDir))) {
+        const inside = (t) => t.includes('*') ? copied.some((p) => wildcardCovers(t, p.root)) : !!(0, workspace_source_1.ownerOf)(copied, t);
+        if (targets.length > 0 && targets.every(inside))
+            copiedAliases[alias] = targets;
+        else
+            otherAliases.push(alias);
+    }
+    const errors = [];
+    const existing = new Set(treeProjectNames(tree));
+    for (const p of projects) {
+        if (tree.exists(p.source.root)) {
+            errors.push(`${code(p.source.root)} already exists in the workspace (source project ${p.source.name}).`);
+        }
+        if (existing.has(p.name)) {
+            errors.push(`a project named "${p.name}" already exists in the workspace.` +
+                (ctx.prefix ? '' : ' Rename the migrated projects with --prefix=<p>.'));
+        }
+    }
+    const wsPaths = workspacePaths(tree);
+    for (const [alias, targets] of Object.entries(copiedAliases)) {
+        const ws = wsPaths[alias];
+        if (ws && JSON.stringify(ws) !== JSON.stringify(targets)) {
+            errors.push(`the path alias "${alias}" maps to ${ws.join(', ')} in the workspace but to ` +
+                `${targets.join(', ')} in the source; imports would resolve to the wrong code.`);
+        }
+    }
+    const npmProjects = projects.some((p) => NPM_KINDS.has(p.source.kind));
+    const rootPkg = (0, pnpm_1.sourceRootPackage)(ctx.sourceDir);
+    if (rootPkg.unresolved.length > 0) {
+        errors.push((0, pnpm_1.catalogMissMessage)('the source root package.json', rootPkg.unresolved));
+    }
+    const mismatch = (0, dependencies_2.angularMismatch)(tree, rootPkg.pkg);
+    if (mismatch && npmProjects && !ctx.forceAngular)
+        errors.push((0, dependencies_2.angularMismatchMessage)(mismatch));
+    if (errors.length > 0) {
+        throw new Error([
+            `migrate: cannot import from ${ctx.sourceDir}. Nothing was written.`,
+            ...errors.map((e) => `- ${e}`),
+        ].join('\n'));
+    }
+    return { all, projects, renames, copiedAliases, otherAliases: otherAliases.sort() };
+}
+exports.planNxImport = planNxImport;
+/** A wildcard alias target (with a `*` segment) that can resolve inside `root`. */
+function wildcardCovers(target, root) {
+    const prefix = target.slice(0, target.indexOf('*'));
+    return root.startsWith(prefix) || `${root}/`.startsWith(prefix) || prefix.startsWith(`${root}/`);
+}
+const WALK_SKIP = new Set(['node_modules', 'dist', 'tmp', 'coverage']);
+/** Names of every project in the workspace tree (project.json `name`, else the folder name). */
+function treeProjectNames(tree) {
+    const names = [];
+    const visit = (dir) => {
+        for (const child of tree.children(dir)) {
+            const rel = dir ? `${dir}/${child}` : child;
+            if (child === 'project.json' && tree.isFile(rel)) {
+                let name;
+                try {
+                    name = (0, devkit_1.readJson)(tree, rel)?.name;
+                }
+                catch {
+                    name = undefined;
+                }
+                names.push(typeof name === 'string' ? name : path.posix.basename(dir));
+            }
+            else if (!tree.isFile(rel) && !WALK_SKIP.has(child) && !child.startsWith('.')) {
+                visit(rel);
+            }
+        }
+    };
+    visit('');
+    return names;
+}
+exports.treeProjectNames = treeProjectNames;
+const NX_IMPORT = /^@(nrwl|nx)\/([^/]+)/;
+const CODE_FILE = /\.(ts|tsx|mts|js|mjs|cjs)$/;
+const schemaPath = (root) => `${'../'.repeat(root.split('/').length)}node_modules/nx/schemas/project-schema.json`;
+const writeJson = (tree, file, value) => tree.write(file, JSON.stringify(value, null, 2) + '\n');
+const ESLINTRC = /(^|\/)\.eslintrc\.json$/;
+const TOO_MANY = 'migrate: the source has more than';
+function dependencyFields(tree) {
+    const pkg = (0, devkit_1.readJson)(tree, 'package.json');
+    return JSON.stringify([pkg.dependencies, pkg.devDependencies, pkg.optionalDependencies]);
+}
+exports.dependencyFields = dependencyFields;
+/** file:/link: specs keep their path when they point into a copied project. */
+function classifyWorkspaceSpec(spec, sourceDir, roots) {
+    const kind = (0, npm_deps_1.classifyDependencySpec)(spec, { sourceDir, copiedDir: sourceDir, projectRoot: '' });
+    if (kind.kind !== 'rebased')
+        return kind;
+    const rel = kind.spec.slice('file:'.length);
+    return roots.some((r) => rel === r || rel.startsWith(`${r}/`))
+        ? kind
+        : { kind: 'outside', target: path.join(sourceDir, rel) };
+}
+exports.classifyWorkspaceSpec = classifyWorkspaceSpec;
+function copyProject(tree, ctx, plan, p, alreadyCopied) {
+    const { root, kind } = p.source;
+    const nested = plan.all
+        .map((o) => o.root)
+        .filter((r) => r !== root && r.startsWith(`${root}/`))
+        .map((r) => r.slice(root.length + 1));
+    const base = kind === 'flutter-app' || kind === 'flutter-lib'
+        ? flutter_1.FLUTTER_SKIP
+        : kind === 'ionic-app'
+            ? (0, skip_1.withIonicSkip)(angular_cli_1.ANGULAR_SKIP_NESTED)
+            : angular_cli_1.ANGULAR_SKIP_NESTED;
+    const rules = { ...base, paths: [...(base.paths ?? []), ...nested] };
+    const maxFiles = ctx.maxFiles ?? copy_1.DEFAULT_MAX_FILES;
+    try {
+        return (0, copy_1.copyIntoTree)(tree, path.join(ctx.sourceDir, ...root.split('/')), root, rules, {
+            ignoreFrom: ctx.sourceDir,
+            maxFiles: maxFiles - alreadyCopied,
+        });
+    }
+    catch (err) {
+        if (err instanceof Error && err.message.startsWith(TOO_MANY)) {
+            throw new Error(`migrate: the selected projects have more than ${maxFiles} files to copy after the skip ` +
+                'lists. Narrow --projects, clean up the source, or raise --max-files.');
+        }
+        throw err;
+    }
+}
+function migrateNxWorkspace(tree, ctx) {
+    const plan = planNxImport(tree, ctx);
+    const { sourceDir } = ctx;
+    const data = { ...(0, types_1.emptyReportData)(), projects: [], unsupported: [] };
+    const roots = plan.projects.map((p) => p.source.root);
+    const pluginPackages = new Set();
+    const usedInputs = new Set();
+    let usesJest = false;
+    let usesNgPackagr = false;
+    if (!tree.exists('package.json'))
+        writeJson(tree, 'package.json', {});
+    const depsBefore = dependencyFields(tree);
+    const namesBefore = (0, dependencies_2.packageNames)(tree);
+    const isNative = (0, packages_1.nativeClassifier)(sourceDir);
+    /** Native packages each copied project's code imports. */
+    const nativeImportsOf = new Map();
+    const ionicApps = [];
+    const sourcePkg = (0, pnpm_1.sourceRootPackage)(sourceDir).pkg;
+    const npmProjects = plan.projects.some((p) => NPM_KINDS.has(p.source.kind));
+    // Folders the projects use that are not projects (assets, styles, environments, tools).
+    const shared = findSharedFolders(ctx, plan, npmProjects ? sourcePkg?.scripts : undefined);
+    copySharedFolders(tree, ctx, shared, data);
+    const buildScripts = (0, build_scripts_1.readBuildScripts)(sourceDir, npmProjects ? sourcePkg?.scripts : undefined, plan.projects.map((p) => p.source.name));
+    const mains = [];
+    for (const p of plan.projects) {
+        const { root, kind } = p.source;
+        const copy = copyProject(tree, ctx, plan, p, data.copied);
+        (0, types_1.recordCopy)(data, copy, root);
+        const dropped = new Set();
+        let config = (0, rewrite_1.rewriteProjectConfig)(p.source.config, p.name, plan.renames, (n) => dropped.add(n));
+        if (p.source.origin !== 'project.json') {
+            const rest = { ...config };
+            delete rest['name'];
+            delete rest['root'];
+            delete rest['$schema'];
+            config = { name: config['name'], $schema: schemaPath(root), ...rest };
+        }
+        if (!(0, workspace_source_1.isObject)(config['targets']))
+            config['targets'] = {};
+        const targets = config['targets'];
+        const tags = Array.isArray(config['tags']) ? [...config['tags']] : [];
+        const addTag = (prefix, tag) => {
+            if (!tags.some((t) => t.startsWith(prefix)))
+                tags.push(tag);
+        };
+        const notes = [];
+        if (kind === 'angular-app' || kind === 'ionic-app') {
+            const releases = (0, angular_project_json_1.addReleaseTarget)(targets, p.name, (w) => notes.push(w), root);
+            // Only the release target this run added; a source's own release target stays as it was.
+            if (releases.length > 0)
+                shapeReleaseTarget(targets, p, buildScripts, notes);
+            const main = mainOf(targets);
+            if (main)
+                mains.push(main);
+            addTag('type:', 'type:app');
+            addTag('platform:', kind === 'ionic-app' ? 'platform:mobile' : 'platform:web');
+            // The source's own scripts of the same name (custom build pipelines) win.
+            const appScripts = (0, angular_project_json_1.angularAppNpmScripts)(p.name, targets['serve'] !== undefined, releases);
+            for (const k of Object.keys(npmProjects ? sourcePkg?.scripts ?? {} : {}))
+                delete appScripts[k];
+            (0, npm_scripts_1.addNpmScripts)(tree, appScripts, { force: false });
+            data.nextSteps.push(`\`npx nx build ${p.name}\``);
+            if (kind === 'ionic-app')
+                ionicApps.push({ p, releases });
+        }
+        else if (kind === 'lib') {
+            addTag('type:', 'type:lib');
+        }
+        else if (kind === 'flutter-app') {
+            const polystack = (0, generator_1.buildProjectJson)(p.name, {
+                exportTarget: false,
+                root,
+                port: (0, serve_port_1.nextFreePort)((0, serve_port_1.usedServePorts)(tree).map((u) => u.port)),
+            }).targets;
+            // A clean target of the source is kept.
+            if (targets['clean'] !== undefined)
+                delete polystack['clean'];
+            const replaced = Object.keys(polystack)
+                .filter((t) => targets[t] !== undefined)
+                .sort();
+            Object.assign(targets, polystack);
+            if (replaced.length > 0) {
+                notes.push(`source targets replaced by the polystack Flutter targets: ${replaced.join(', ')}`);
+            }
+            addTag('type:', 'type:app');
+            addTag('platform:', 'platform:flutter');
+            const created = (0, env_files_1.generateFlutterEnvFiles)(tree, p.name, {
+                keepExisting: true,
+                empty: true,
+                root,
+            });
+            if (created.length > 0) {
+                notes.push(`created empty ${created.map(code).join(', ')}; fill them (they are passed to Flutter ` +
+                    'with `--dart-define-from-file`)');
+            }
+            (0, npm_scripts_1.addNpmScripts)(tree, (0, generator_1.buildNpmScripts)(p.name, { exportTarget: false }), { force: false });
+            data.nextSteps.push(`\`cd ${root} && flutter pub get\``, `\`npx nx run ${p.name}:build-web:dev\``);
+        }
+        config['tags'] = tags;
+        for (const executor of (0, rewrite_1.executorsOf)(config)) {
+            const pkg = (0, rewrite_1.nxPluginPackage)(executor);
+            if (pkg)
+                pluginPackages.add(pkg);
+            if (executor === '@nx/jest:jest')
+                usesJest = true;
+            if (/^@nx\/angular:(package|ng-packagr-lite)$/.test(executor))
+                usesNgPackagr = true;
+        }
+        for (const input of namedInputsOf(targets))
+            usedInputs.add(input);
+        writeJson(tree, `${root}/project.json`, config);
+        if (dropped.size > 0) {
+            notes.push(`dropped references to projects that were not copied: ${[...dropped]
+                .sort()
+                .map(code)
+                .join(', ')} (implicitDependencies / dependsOn); Nx fails on unknown projects`);
+        }
+        const nrwlImports = [];
+        for (const f of copy.copied.filter((c) => CODE_FILE.test(c))) {
+            const text = tree.read(`${root}/${f}`, 'utf8') ?? '';
+            let nrwl = false;
+            for (const spec of (0, selection_1.importSpecifiers)(text)) {
+                const pkgName = (0, packages_1.packageOfSpecifier)(spec);
+                if ((0, packages_1.isWebCodeFile)(f) && isNative(pkgName)) {
+                    const set = nativeImportsOf.get(p.name) ?? new Set();
+                    set.add(pkgName);
+                    nativeImportsOf.set(p.name, set);
+                }
+                const m = NX_IMPORT.exec(spec);
+                if (!m)
+                    continue;
+                pluginPackages.add(`@nx/${m[2]}`);
+                if (m[1] === 'nrwl')
+                    nrwl = true;
+            }
+            if (nrwl)
+                nrwlImports.push(`${root}/${f}`);
+        }
+        if (nrwlImports.length > 0 && !ctx.rewriteImports) {
+            notes.push(`these files import \`@nrwl/*\` packages; rename the imports to \`@nx/*\`: ` +
+                nrwlImports.map(code).join(', '));
+        }
+        if (kind === 'flutter-app' && !/^apps\/[^/]+$/.test(root)) {
+            notes.push(`\`pstack env\` only updates apps directly under \`apps/\`; add new env files to ` +
+                `${code(`${root}/env`)} and configurations to its build targets by hand`);
+        }
+        for (const f of copy.copied.filter((c) => ESLINTRC.test(c))) {
+            const file = `${root}/${f}`;
+            writeJson(tree, file, (0, rewrite_1.rewriteEslintConfig)((0, source_1.parseJsonStrict)(tree.read(file, 'utf8') ?? '', file)));
+        }
+        if (targets['lint'] !== undefined)
+            data.nextSteps.push(`\`npx nx lint ${p.name}\``);
+        const outside = (0, rewrite_1.outsidePaths)(config, roots, (first) => (0, source_1.sourceExists)(sourceDir, first) || tree.exists(first)).filter((o) => !tree.exists(o));
+        if (outside.length > 0) {
+            notes.push(`options point outside the copied projects, at paths the workspace does not have: ` +
+                `${outside.map(code).join(', ')}. Copy them or change the options.`);
+        }
+        data.notes.push(...notes.map((n) => `${code(p.name)}: ${n}`));
+        data.projects.push({
+            name: p.name,
+            sourceName: p.source.name,
+            kind,
+            root,
+            why: p.neededBy.length === 0
+                ? 'selected'
+                : `needed by ${p.neededBy.map((n) => plan.renames.get(n) ?? n).join(', ')}`,
+        });
+    }
+    data.unsupported = plan.all
+        .filter((p) => !(0, workspace_source_1.isSupportedKind)(p.kind))
+        .map((p) => ({ name: p.name, kind: p.kind, root: p.root || '.' }));
+    // tsconfig.base.json: aliases of copied projects, as they were.
+    const aliasNames = Object.keys(plan.copiedAliases).sort();
+    if (aliasNames.length > 0) {
+        if (!tree.exists('tsconfig.base.json'))
+            writeJson(tree, 'tsconfig.base.json', { compilerOptions: {} });
+        (0, devkit_1.updateJson)(tree, 'tsconfig.base.json', (json) => {
+            const co = json.compilerOptions ?? {};
+            const paths = { ...(co.paths ?? {}) };
+            for (const alias of aliasNames) {
+                if (paths[alias] !== undefined)
+                    continue;
+                paths[alias] = plan.copiedAliases[alias];
+                data.tsPathsAdded.push(alias);
+            }
+            json.compilerOptions = { ...co, paths };
+            return json;
+        });
+    }
+    if (plan.otherAliases.length > 0) {
+        data.notes.push(`Path aliases of projects that were not copied (not added): ${plan.otherAliases
+            .map(code)
+            .join(', ')}.`);
+    }
+    const sourceTs = (0, source_1.readSourceJson)(sourceDir, 'tsconfig.base.json');
+    const sourceCo = (0, workspace_source_1.objectField)(sourceTs, 'compilerOptions');
+    const workspaceCo = (tree.exists('tsconfig.base.json')
+        ? (0, devkit_1.readJson)(tree, 'tsconfig.base.json').compilerOptions ?? {}
+        : {});
+    // Options the workspace base does not set are added, so the copied code compiles as before
+    // (allowJs for imported .js files, strict: false, …); options it sets differently are listed.
+    const NOT_CARRIED = new Set(['paths', 'baseUrl', 'rootDir', 'outDir']);
+    const missing = Object.keys(sourceCo)
+        .filter((k) => !NOT_CARRIED.has(k) && workspaceCo[k] === undefined)
+        .sort();
+    const differing = Object.keys(sourceCo)
+        .filter((k) => !NOT_CARRIED.has(k) && workspaceCo[k] !== undefined)
+        .filter((k) => JSON.stringify(sourceCo[k]) !== JSON.stringify(workspaceCo[k]))
+        .sort();
+    const sourceNg = (0, workspace_source_1.objectField)(sourceTs, 'angularCompilerOptions');
+    const workspaceNg = (tree.exists('tsconfig.base.json')
+        ? (0, devkit_1.readJson)(tree, 'tsconfig.base.json').angularCompilerOptions ?? {}
+        : {});
+    const missingNg = Object.keys(sourceNg)
+        .filter((k) => workspaceNg[k] === undefined)
+        .sort();
+    if ((missing.length > 0 || missingNg.length > 0) && tree.exists('tsconfig.base.json')) {
+        (0, devkit_1.updateJson)(tree, 'tsconfig.base.json', (json) => {
+            json.compilerOptions = { ...(json.compilerOptions ?? {}) };
+            for (const k of missing)
+                json.compilerOptions[k] = sourceCo[k];
+            if (missingNg.length > 0) {
+                json.angularCompilerOptions = { ...(json.angularCompilerOptions ?? {}) };
+                for (const k of missingNg)
+                    json.angularCompilerOptions[k] = sourceNg[k];
+            }
+            return json;
+        });
+        data.notes.push('Added to `tsconfig.base.json` from the source (the workspace did not set them): ' +
+            [
+                ...missing.map((k) => code(`${k}: ${JSON.stringify(sourceCo[k])}`)),
+                ...missingNg.map((k) => code(`angularCompilerOptions.${k}: ${JSON.stringify(sourceNg[k])}`)),
+            ].join(', ') +
+            '. They apply to every project of the workspace.');
+    }
+    if (differing.length > 0) {
+        data.notes.push('The source `tsconfig.base.json` sets compilerOptions the workspace has with other ' +
+            `values: ${differing
+                .map((k) => code(`${k}: ${JSON.stringify(sourceCo[k])}`))
+                .join(', ')}. ` +
+            "The workspace values were kept; set them in the projects' tsconfig files if the code " +
+            'needs them.');
+    }
+    // package.json: only when npm projects were copied.
+    const ionicNames = new Set(ionicApps.map((a) => a.p.name));
+    const importedAnywhere = new Set([...nativeImportsOf.values()].flatMap((s) => [...s]));
+    const importedByShared = new Set([...nativeImportsOf].filter(([n]) => !ionicNames.has(n)).flatMap(([, set]) => [...set]));
+    data.npmProject = plan.projects.some((p) => NPM_KINDS.has(p.source.kind));
+    if (data.npmProject) {
+        (0, dependencies_2.mergeDependencies)(tree, {
+            sourceDir,
+            sourcePkg,
+            classify: (spec) => classifyWorkspaceSpec(spec, sourceDir, roots),
+            copiedLabel: 'copied projects',
+            angular: (0, source_1.sourceDependency)(sourcePkg, '@angular/core') !== undefined,
+            skip: {
+                test: (pkgName) => /^(@nrwl\/|@nx\/|@nxext\/|nx$)/.test(pkgName) ||
+                    (ionicApps.length > 0 && isNative(pkgName) && !importedAnywhere.has(pkgName)),
+                reason: ionicApps.length > 0
+                    ? "the source's Nx packages (the workspace keeps its own Nx version) and native " +
+                        "packages no copied code imports (they are in the Ionic apps' own package.json)"
+                    : "the source's Nx packages; the workspace keeps its own Nx version",
+            },
+        }, data);
+        data.sourceScripts = carryRootPackageFields(tree, sourcePkg, data, scriptContext(plan));
+    }
+    const nonceNote = (0, csp_nonce_1.noncePatchMains)(tree, mains);
+    if (nonceNote)
+        data.notes.push(nonceNote);
+    // The source's own env encryption: same output from the release build, library runtime module.
+    const envEncryption = (0, env_encryption_1.applySourceEnvEncryption)(tree, sourceDir, data.notes, plan.projects.map((p) => p.source.root));
+    (0, env_encryption_1.swapEnvSecretModules)(tree, [...plan.projects.map((p) => p.source.root), ...shared.folders.map((f) => f.path)], data.notes, sourceDir);
+    noteBuildScripts(buildScripts, data, envEncryption?.applied === true);
+    if (shared.usedBaseUrl)
+        baseUrlForImports(tree, sourceDir, data);
+    // Ionic apps: after every project.json is written and the root merge ran.
+    const installApps = [];
+    if (ionicApps.length > 0)
+        data.ionic = [];
+    for (const { p, releases } of ionicApps) {
+        const { report, installApp } = (0, shape_1.applyIonicShape)(tree, {
+            name: p.name,
+            appRoot: p.source.root,
+            sourcePkg,
+            isNative,
+            // Several Ionic apps: each gets the platform packages, what it or the shared code imports,
+            // and what no copied code imports.
+            forThisApp: ionicApps.length > 1
+                ? (n) => packages_1.PLATFORM_PACKAGES.has(n) ||
+                    (nativeImportsOf.get(p.name)?.has(n) ?? false) ||
+                    importedByShared.has(n) ||
+                    !importedAnywhere.has(n)
+                : undefined,
+            alsoAtRoot: importedAnywhere,
+            releaseConfigurations: releases,
+        });
+        data.ionic?.push(report);
+        if (installApp)
+            installApps.push(installApp);
+        data.nextSteps.push(`\`npx nx run ${p.name}:release:prod\``, `\`npx nx run ${p.name}:cap-sync --platform=android\``);
+    }
+    const nx = (0, dependencies_1.nxVersion)(tree);
+    (0, dependencies_1.addMissingDependencies)(tree, {}, Object.fromEntries([...pluginPackages].sort().map((pkg) => [pkg, nx])));
+    if (usesNgPackagr) {
+        (0, dependencies_1.addMissingDependencies)(tree, {}, (0, angular_deps_1.ngPackagrDependencies)((0, dependencies_1.declaredVersion)(tree, '@angular/core')));
+    }
+    addNamedInputs(tree, sourceDir, usedInputs, data);
+    if (usesJest) {
+        const sourceJest = (0, source_1.sourceDependency)(sourcePkg, 'jest');
+        const jestMajor = sourceJest ? (0, dependencies_1.majorOf)(sourceJest) : undefined;
+        if (jestMajor !== undefined && jestMajor < 29) {
+            data.notes.push(`The source used Jest ${sourceJest}; the workspace's \`@nx/jest\` ${(0, dependencies_1.nxVersion)(tree)} ` +
+                'needs Jest 29. Update `jest`, `jest-environment-jsdom`, `ts-jest` and `@types/jest` to ' +
+                '29, and `jest-preset-angular` to 13 (Angular 15), before running the tests.');
+        }
+        for (const file of ['jest.preset.js', 'jest.config.ts']) {
+            if (tree.exists(file))
+                continue;
+            const text = (0, source_1.readSourceText)(sourceDir, file);
+            if (text === undefined || (file === 'jest.config.ts' && !text.includes('getJestProjects'))) {
+                continue;
+            }
+            tree.write(file, text.replace(/@nrwl\/jest/g, '@nx/jest'));
+            data.notes.push(`Copied ${code(file)} from the source (the copied projects' Jest configs use it).`);
+        }
+    }
+    const rootEslint = (0, source_1.readSourceJson)(sourceDir, '.eslintrc.json');
+    const constraints = rootEslint ? (0, rewrite_1.depConstraints)(rootEslint) : [];
+    if (constraints.length > 0) {
+        data.notes.push("The source's root ESLint config was not copied. Its module-boundary rules " +
+            `(\`depConstraints\`) were: ${constraints.map(code).join(', ')}. Add the ones you want ` +
+            'to the workspace `.eslintrc.json`.');
+    }
+    const sourceNx = (0, workspace_source_1.sourceNxVersion)(sourceDir);
+    const workspaceNx = (0, dependencies_1.declaredVersion)(tree, 'nx');
+    if (sourceNx && workspaceNx && (0, dependencies_1.majorOf)(sourceNx) !== (0, dependencies_1.majorOf)(workspaceNx)) {
+        data.notes.push(`The source used Nx ${sourceNx}; the workspace has Nx ${workspaceNx}. \`@nrwl/*\` ` +
+            'executors were renamed to `@nx/*`; check each target with `npx nx show project <name>`.');
+    }
+    data.nextSteps.push('`pstack env --name=<env>` adds an environment to every app; migrated Angular apps keep ' +
+        'their own environment files and fileReplacements');
+    // Everything this run added (source dependencies, @nx plugins, build packages), sorted.
+    data.dependenciesAdded = [...(0, dependencies_2.packageNames)(tree)].filter((n) => !namesBefore.has(n)).sort();
+    const rootInstall = dependencyFields(tree) !== depsBefore ? () => (0, devkit_1.installPackagesTask)(tree) : undefined;
+    data.installTask =
+        rootInstall || installApps.length > 0
+            ? async () => {
+                if (rootInstall)
+                    rootInstall();
+                for (const install of installApps)
+                    await install();
+            }
+            : undefined;
+    return data;
+}
+/** A named input reference: not a file set ({…}), negation, path or dependency object. */
+function inputName(entry) {
+    if (typeof entry !== 'string')
+        return undefined;
+    const name = entry.replace(/^\^/, '');
+    return /^[A-Za-z0-9_-]+$/.test(name) ? name : undefined;
+}
+/** Named inputs referenced by the targets' `inputs`. */
+function namedInputsOf(targets) {
+    const out = [];
+    for (const target of Object.values(targets)) {
+        const inputs = (0, workspace_source_1.isObject)(target) ? target['inputs'] : undefined;
+        if (!Array.isArray(inputs))
+            continue;
+        for (const entry of inputs) {
+            const name = inputName(entry);
+            if (name)
+                out.push(name);
+        }
+    }
+    return out;
+}
+/**
+ * Named inputs the copied targets use but the workspace nx.json lacks: copied from the source
+ * nx.json (with the ones they refer to), the rest listed.
+ */
+function addNamedInputs(tree, sourceDir, used, data) {
+    if (used.size === 0)
+        return;
+    const workspaceNx = tree.exists('nx.json') ? (0, devkit_1.readJson)(tree, 'nx.json') : {};
+    const workspaceNamed = ((0, workspace_source_1.isObject)(workspaceNx.namedInputs) ? workspaceNx.namedInputs : {});
+    const sourceNx = (0, source_1.readSourceJson)(sourceDir, 'nx.json');
+    const sourceNamed = (0, workspace_source_1.objectField)(sourceNx, 'namedInputs');
+    const added = {};
+    const unknown = new Set();
+    const queue = [...used];
+    for (let name = queue.shift(); name !== undefined; name = queue.shift()) {
+        if (workspaceNamed[name] !== undefined || added[name] !== undefined || unknown.has(name)) {
+            continue;
+        }
+        const definition = sourceNamed[name];
+        if (definition === undefined) {
+            unknown.add(name);
+            continue;
+        }
+        added[name] = definition;
+        if (Array.isArray(definition)) {
+            for (const entry of definition) {
+                const ref = inputName(entry);
+                if (ref)
+                    queue.push(ref);
+            }
+        }
+    }
+    const addedNames = Object.keys(added).sort();
+    if (addedNames.length > 0) {
+        if (!tree.exists('nx.json'))
+            writeJson(tree, 'nx.json', {});
+        (0, devkit_1.updateJson)(tree, 'nx.json', (json) => {
+            json.namedInputs = { ...(json.namedInputs ?? {}), ...added };
+            return json;
+        });
+        data.notes.push(`Added named inputs to \`nx.json\`: ${addedNames.map(code).join(', ')} (from the source, ` +
+            'used by the copied targets).');
+    }
+    if (unknown.size > 0) {
+        data.notes.push('The copied targets use named inputs that neither `nx.json` defines: ' +
+            `${[...unknown].sort().map(code).join(', ')}. Define them under \`namedInputs\` in ` +
+            '`nx.json`, or remove them from the targets.');
+    }
+}
+exports.nxWorkspaceAdapter = {
+    kind: 'workspace',
+    id: 'nx-workspace',
+    label: 'Nx workspace (Angular, Ionic and Flutter projects)',
+    detect: detect_1.detectNxWorkspace,
+    defaultName(sourceDir) {
+        const name = (0, source_1.readSourcePackageJson)(sourceDir)?.name;
+        return name ? name.replace(/^@[^/]+\//, '') : path.basename(sourceDir);
+    },
+    preflight(tree, ctx) {
+        planNxImport(tree, ctx);
+    },
+    migrate: migrateNxWorkspace,
+};
+// ── Shared folders, release targets and root package.json (multi-app sources) ──────────────────
+const SHARED_SKIP = { anyDepth: ['node_modules', '.git'], topLevel: [] };
+function findSharedFolders(ctx, plan, scripts) {
+    const { sourceDir } = ctx;
+    const sourceTs = (0, source_1.readSourceJson)(sourceDir, 'tsconfig.base.json');
+    const baseUrl = (0, workspace_source_1.objectField)(sourceTs, 'compilerOptions')['baseUrl'];
+    const baseUrlRoot = baseUrl === '.' || baseUrl === './';
+    const finder = new shared_folders_1.SharedFolderFinder({
+        sourceDir,
+        projectRoots: plan.all.map((p) => p.root),
+        selectedRoots: plan.projects.map((p) => p.source.root),
+    });
+    const scanCode = (root) => {
+        for (const file of (0, workspace_source_1.listProjectFiles)(sourceDir, root)) {
+            if (!(CODE_FILE.test(file) || STYLE_FILE.test(file)) || file.endsWith('.d.ts'))
+                continue;
+            const full = root ? `${root}/${file}` : file;
+            const text = (0, source_1.readSourceText)(sourceDir, full);
+            if (text !== undefined)
+                finder.addCode(full, text, baseUrlRoot);
+        }
+    };
+    for (const p of plan.projects) {
+        finder.addProjectConfig(p.source.name, p.source.config);
+        scanCode(p.source.root);
+    }
+    finder.addTsconfig(sourceTs);
+    finder.addScripts(scripts);
+    // Shared folders may import further ones (an env file importing a config folder).
+    const scanned = new Set();
+    for (let round = 0; round < 3; round++) {
+        const next = finder.folders().filter((f) => !scanned.has(f.path));
+        if (next.length === 0)
+            break;
+        for (const f of next) {
+            scanned.add(f.path);
+            scanCode(f.path);
+        }
+    }
+    return {
+        folders: finder.folders(),
+        rootFiles: finder.rootFiles(),
+        usedBaseUrl: finder.usedBaseUrl,
+        unselected: finder.unselectedReferences(),
+    };
+}
+const STYLE_FILE = /\.(scss|sass|css|less)$/;
+function copySharedFolders(tree, ctx, finding, data) {
+    copyRootFiles(tree, ctx, finding.rootFiles, data);
+    // Code imports into those projects are reported by the import rewriting; options are not.
+    const unselected = finding.unselected
+        .map(([root, why]) => [
+        root,
+        why.filter((w) => !w.startsWith('imported by')),
+    ])
+        .filter(([, why]) => why.length > 0);
+    if (unselected.length > 0) {
+        data.notes.push(`Options of the copied projects reach into projects that were not selected: ${unselected
+            .map(([root, why]) => `${code(root)} (${why.slice(0, 2).join('; ')})`)
+            .join(', ')}. Add them with \`--projects\` or change those paths.`);
+    }
+    const folders = finding.folders;
+    if (folders.length === 0)
+        return;
+    const maxFiles = ctx.maxFiles ?? copy_1.DEFAULT_MAX_FILES;
+    const lines = [];
+    const kept = [];
+    for (const f of folders) {
+        let copy;
+        try {
+            copy = (0, copy_1.copyIntoTree)(tree, path.join(ctx.sourceDir, ...f.path.split('/')), f.path, SHARED_SKIP, {
+                ignoreFrom: ctx.sourceDir,
+                maxFiles: maxFiles - data.copied,
+                keepExisting: true,
+            });
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.startsWith(TOO_MANY)) {
+                throw new Error(`migrate: the selected projects and the folders they use have more than ${maxFiles} ` +
+                    'files to copy after the skip lists. Narrow --projects, clean up the source, or raise ' +
+                    '--max-files.');
+            }
+            throw err;
+        }
+        (0, types_1.recordCopy)(data, copy, f.path);
+        kept.push(...(copy.existing ?? []).map((e) => `${f.path}/${e}`));
+        const why = f.reasons.slice(0, 3).join('; ') + (f.reasons.length > 3 ? '; …' : '');
+        lines.push(`${code(f.path)} (${copy.copied.length} file${copy.copied.length === 1 ? '' : 's'}; ${why})`);
+    }
+    data.notes.push(`Copied folders the projects use that are not Nx projects, at the same paths: ${lines.join(', ')}.`);
+    if (kept.length > 0) {
+        data.notes.push(`Files the workspace already had were kept, not overwritten: ${kept
+            .slice(0, 10)
+            .map(code)
+            .join(', ')}${kept.length > 10 ? ` and ${kept.length - 10} more` : ''}. Compare them ` +
+            'with the source.');
+    }
+}
+/** Root files that options or npm scripts use (not secrets, not already in the workspace). */
+function copyRootFiles(tree, ctx, files, data) {
+    const copied = [];
+    const existing = [];
+    for (const f of files) {
+        if ((0, copy_1.isPossibleSecret)(f.path)) {
+            if (!data.secrets.includes(f.path))
+                data.secrets.push(f.path);
+            continue;
+        }
+        if (tree.exists(f.path)) {
+            existing.push(f.path);
+            continue;
+        }
+        const abs = path.join(ctx.sourceDir, f.path);
+        tree.write(f.path, fs.readFileSync(abs), { mode: fs.statSync(abs).mode & 0o777 });
+        data.copied += 1;
+        copied.push(`${code(f.path)} (${f.reasons.slice(0, 2).join('; ')})`);
+    }
+    if (copied.length > 0) {
+        data.notes.push(`Copied root files the projects or npm scripts use: ${copied.join(', ')}.`);
+    }
+    if (existing.length > 0) {
+        data.notes.push(`Root files the workspace already had were kept: ${existing.map(code).join(', ')}. ` +
+            'Compare them with the source.');
+    }
+}
+const mainOf = (targets) => {
+    const main = (0, workspace_source_1.objectField)(targets, 'build')['options']?.['main'];
+    return typeof main === 'string' ? main : undefined;
+};
+/**
+ * The release target of a migrated app: the env folder its fileReplacements use
+ * (environments/<x>/…), and base hrefs from the source's build scripts.
+ */
+function shapeReleaseTarget(targets, p, scripts, notes) {
+    const release = targets['release'];
+    if (!(0, workspace_source_1.isObject)(release) || !(0, workspace_source_1.isObject)(release['options']))
+        return;
+    const options = release['options'];
+    const envProject = envFolderOf((0, workspace_source_1.objectField)(targets, 'build'));
+    if (envProject && envProject !== options['envProject'])
+        options['envProject'] = envProject;
+    const hrefs = scripts.baseHrefs.get(p.source.name);
+    if (!hrefs)
+        return;
+    const configurations = (0, workspace_source_1.isObject)(release['configurations'])
+        ? release['configurations']
+        : {};
+    const applied = [];
+    for (const [name, config] of Object.entries(configurations)) {
+        const href = hrefs[name] ?? hrefs['*'];
+        if (!href || href === '/' || !(0, workspace_source_1.isObject)(config))
+            continue;
+        config['baseHref'] = href;
+        applied.push(`${name}: ${href}`);
+    }
+    if (applied.length > 0) {
+        notes.push(`release target base hrefs from the source build scripts: ${applied.join(', ')}`);
+    }
+}
+/** "environments/<x>/environment.prod.ts" in the build's fileReplacements → "<x>". */
+function envFolderOf(build) {
+    const sets = [build['options'], ...Object.values((0, workspace_source_1.objectField)(build, 'configurations'))];
+    for (const set of sets) {
+        const replacements = (0, workspace_source_1.isObject)(set) ? set['fileReplacements'] : undefined;
+        if (!Array.isArray(replacements))
+            continue;
+        for (const r of replacements) {
+            const w = (0, workspace_source_1.isObject)(r) ? r['with'] ?? r['replaceWith'] : undefined;
+            const m = typeof w === 'string' ? /^(?:\.\/)?environments\/([^/]+)\/[^/]+$/.exec(w) : null;
+            if (m)
+                return m[1];
+        }
+    }
+    return undefined;
+}
+const scriptContext = (plan) => ({
+    renames: plan.renames,
+    all: new Set(plan.all.map((p) => p.name)),
+});
+/** Project names a script command refers to, with where each one is (for renaming). */
+const SCRIPT_PROJECT_REFS = [
+    // nx/ng <verb> <project> (not run, run-many, affected, graph, …)
+    /\b(?:nx|ng)\s+(?!run\b|run-many\b|affected\b|graph\b|g\b|generate\b|migrate\b|reset\b|show\b)[\w:-]+\s+(?!-)([\w.-]+)/g,
+    // nx run <project>:<target>
+    /\bnx\s+run\s+([\w.-]+):/g,
+    // --project=<p>, --projects=<a,b>, --app=<p>
+    /--(?:projects?|app)[=\s]+(['"]?)([\w.,-]+)\1/g,
+];
+/**
+ * The script with project names renamed, or why it is not carried (a project not imported).
+ * `--project=`/`--app=` are renamed only in nx/ng commands: a custom script (`node build.js
+ * --project=web`) looks the name up itself (base-href maps, env folders), so it keeps the source
+ * name and is listed in `sourceNames`.
+ */
+function rewriteScript(command, ctx) {
+    const missing = new Set();
+    const sourceNames = new Set();
+    const rename = (name) => {
+        if (!ctx.all.has(name))
+            return name;
+        const to = ctx.renames.get(name);
+        if (to === undefined)
+            missing.add(name);
+        return to ?? name;
+    };
+    const segments = command.split(/(&&|\|\||;|\|)/);
+    const out = segments
+        .map((seg) => {
+        if (/^(&&|\|\||;|\|)$/.test(seg))
+            return seg;
+        let s = seg.replace(SCRIPT_PROJECT_REFS[0], (m, name) => m.slice(0, m.length - name.length) + rename(name));
+        s = s.replace(SCRIPT_PROJECT_REFS[1], (m, name) => m.replace(name, rename(name)));
+        const nxCommand = /^\s*(?:npx\s+)?(?:nx|ng)\s/.test(s);
+        s = s.replace(SCRIPT_PROJECT_REFS[2], (m, _q, list) => {
+            const names = list.split(',');
+            if (nxCommand)
+                return m.replace(list, names.map(rename).join(','));
+            for (const n of names) {
+                const to = rename(n);
+                if (to !== n)
+                    sourceNames.add(n);
+            }
+            return m;
+        });
+        return s;
+    })
+        .join('');
+    return missing.size > 0
+        ? { missing: [...missing].sort() }
+        : { command: out, sourceNames: [...sourceNames].sort() };
+}
+exports.rewriteScript = rewriteScript;
+function carryRootPackageFields(tree, sourcePkg, data, scriptCtx) {
+    if (!sourcePkg)
+        return {};
+    const added = [];
+    const clashes = [];
+    const notCarried = {};
+    const keptScripts = [];
+    const renamedScripts = [];
+    const lifecycle = [];
+    const forMissing = [];
+    const sourceNamed = [];
+    const nodeMajor = (0, node_engine_1.workspaceNodeMajor)(tree);
+    let nodeKept;
+    (0, devkit_1.updateJson)(tree, 'package.json', (json) => {
+        for (const field of ['overrides', 'engines', 'browser']) {
+            const from = sourcePkg[field];
+            if (from === undefined)
+                continue;
+            if ((0, workspace_source_1.isObject)(from)) {
+                const into = (0, workspace_source_1.isObject)(json[field]) ? json[field] : {};
+                for (const [k, v] of Object.entries(from)) {
+                    // A Node range the workspace's own Node (.nvmrc) is outside of would stop npm install
+                    // (engine-strict) or the workspace tooling, so it is reported instead.
+                    const allows = field === 'engines' && k === 'node' && nodeMajor !== undefined && into[k] === undefined
+                        ? (0, node_engine_1.nodeRangeAllowsMajor)(String(v), nodeMajor)
+                        : true;
+                    if (allows !== true) {
+                        nodeKept = { range: String(v), unreadable: allows === undefined };
+                        continue;
+                    }
+                    if (into[k] === undefined) {
+                        into[k] = v;
+                        added.push(`${field}.${k}`);
+                    }
+                    else if (JSON.stringify(into[k]) !== JSON.stringify(v)) {
+                        clashes.push(`${field}.${k}`);
+                    }
+                }
+                json[field] = into;
+            }
+            else if (json[field] === undefined) {
+                json[field] = from;
+                added.push(field);
+            }
+            else if (JSON.stringify(json[field]) !== JSON.stringify(from)) {
+                clashes.push(field);
+            }
+        }
+        const scripts = (0, workspace_source_1.isObject)(json.scripts) ? json.scripts : {};
+        for (const [k, v] of Object.entries((0, workspace_source_1.isObject)(sourcePkg['scripts']) ? sourcePkg['scripts'] : {})) {
+            if (shared_folders_1.LIFECYCLE_SCRIPTS.has(k)) {
+                if (scripts[k] !== v)
+                    lifecycle.push(k);
+                continue;
+            }
+            const rewritten = typeof v === 'string' ? rewriteScript(v, scriptCtx) : { command: v, sourceNames: [] };
+            if ('missing' in rewritten) {
+                forMissing.push(`${code(k)} (${rewritten.missing.map(code).join(', ')})`);
+                continue;
+            }
+            if (scripts[k] === undefined) {
+                scripts[k] = rewritten.command;
+                keptScripts.push(k);
+                if (rewritten.command !== v)
+                    renamedScripts.push(k);
+                for (const n of rewritten.sourceNames) {
+                    sourceNamed.push(`${code(k)} (\`${n}\` → \`${scriptCtx.renames.get(n)}\`)`);
+                }
+            }
+            else if (scripts[k] !== rewritten.command) {
+                notCarried[k] = v;
+            }
+        }
+        json.scripts = scripts;
+        return json;
+    });
+    const lockfile = ['pnpm-lock.yaml', 'yarn.lock'].find((f) => tree.exists(f));
+    if (lockfile && added.some((a) => a.startsWith('overrides.'))) {
+        data.notes.push(`The workspace uses ${lockfile === 'yarn.lock' ? 'Yarn' : 'pnpm'} (\`${lockfile}\`), which ` +
+            `ignores npm \`overrides\`: move them to \`${lockfile === 'yarn.lock' ? 'resolutions' : 'pnpm.overrides'}\`.`);
+    }
+    // Carried, so no longer listed under "Other package.json fields".
+    data.packageFields = data.packageFields.filter((f) => f.field !== 'overrides');
+    if (added.length > 0) {
+        data.notes.push(`Carried from the source root \`package.json\`: ${added.map(code).join(', ')} (dependency ` +
+            'overrides, browser field and engines the install and build rely on).');
+    }
+    if (nodeKept !== undefined) {
+        data.notes.push(nodeKept.unreadable
+            ? `The source root \`package.json\` sets \`engines.node\` to ${code(nodeKept.range)}, which could not be checked against the workspace's Node ${nodeMajor} ` +
+                '(`.nvmrc`); it was not carried over (npm installs with `engine-strict`). Add it by ' +
+                `hand if it allows Node ${nodeMajor}.`
+            : `The source root \`package.json\` sets \`engines.node\` to ${code(nodeKept.range)}; it was not carried over because the workspace runs Node ${nodeMajor} ` +
+                '(`.nvmrc`), which its tooling needs. Check that the migrated apps build on that Node.');
+    }
+    if (clashes.length > 0) {
+        data.notes.push(`The source root \`package.json\` sets ${clashes.map(code).join(', ')} differently from ` +
+            'the workspace; the workspace values were kept. Compare them.');
+    }
+    if (lifecycle.length > 0) {
+        data.notes.push(`npm lifecycle scripts of the source were not carried over (they run on every install): ` +
+            `${lifecycle
+                .sort()
+                .map((k) => `${code(k)}: ${code(String(sourcePkg['scripts'][k]))}`)
+                .join(', ')}. Add what the workspace still needs by hand.`);
+    }
+    if (forMissing.length > 0) {
+        data.notes.push(`npm scripts for projects that were not imported were not carried over: ${forMissing.join(', ')}.`);
+    }
+    if (sourceNamed.length > 0) {
+        data.notes.push(`These kept npm scripts pass the source project name to a custom script, which looks it ` +
+            `up itself (base hrefs, env folders): ${sourceNamed.join(', ')}. The Nx project has the ` +
+            'new name: update the `nx build`/`nx run` calls inside the script.');
+    }
+    if (renamedScripts.length > 0) {
+        data.notes.push(`Project names were renamed (\`--prefix\`) in the kept npm scripts ${renamedScripts
+            .sort()
+            .map(code)
+            .join(', ')}. Scripts they run (e.g. a custom build script) may still use the old names ` +
+            'inside; update them by hand.');
+    }
+    if (keptScripts.length > 0) {
+        data.notes.push(`Source npm scripts kept in the workspace \`package.json\`: ${keptScripts
+            .sort()
+            .slice(0, 12)
+            .map(code)
+            .join(', ')}${keptScripts.length > 12 ? ` and ${keptScripts.length - 12} more` : ''}.`);
+    }
+    return notCarried;
+}
+function noteBuildScripts(info, data, envEncryptionApplied = false) {
+    const names = Object.keys(info.customBuilds).sort();
+    if (names.length === 0)
+        return;
+    data.notes.push(`The source builds its apps through ${info.customScripts.map(code).join(', ')} ` +
+        `(npm scripts ${names.slice(0, 6).map(code).join(', ')}${names.length > 6 ? ` and ${names.length - 6} more` : ''}). Those scripts ` +
+        'were kept and stay the way to build these apps for now: the polystack `release` target ' +
+        'was added alongside (`npx nx run <app>:release:<env>`), but it does not run their extra ' +
+        (envEncryptionApplied
+            ? 'steps (obfuscation, comment stripping, …); env encryption is set up to match theirs, ' +
+                'and the stamp fields when they set them (see the env encryption note). '
+            : 'steps (env encryption as they do it, stamping, obfuscation, …). ') +
+        'Npm scripts of the same name keep the source command.');
+    if (info.unread.length > 0) {
+        data.notes.push(`Base hrefs for ${info.unread.map(code).join(', ')} could not be read from the build ` +
+            "scripts; set `baseHref` on their release target's configurations.");
+    }
+}
+/** Non-relative imports through `baseUrl: "."` (e.g. `environments/x/y`) need it in the workspace. */
+function baseUrlForImports(tree, sourceDir, data) {
+    const sourceCo = (0, workspace_source_1.objectField)((0, source_1.readSourceJson)(sourceDir, 'tsconfig.base.json'), 'compilerOptions');
+    const baseUrl = sourceCo['baseUrl'];
+    if (typeof baseUrl !== 'string' || !tree.exists('tsconfig.base.json'))
+        return;
+    const ws = (0, devkit_1.readJson)(tree, 'tsconfig.base.json');
+    const wsBase = ws?.compilerOptions?.baseUrl;
+    if (wsBase === undefined) {
+        (0, devkit_1.updateJson)(tree, 'tsconfig.base.json', (json) => {
+            json.compilerOptions = { ...(json.compilerOptions ?? {}), baseUrl };
+            return json;
+        });
+        data.notes.push(`Set \`baseUrl: "${baseUrl}"\` in \`tsconfig.base.json\` as the source had it; imports ` +
+            'such as `environments/<app>/…` resolve through it.');
+    }
+    else if (path.posix.normalize(wsBase) !== path.posix.normalize(baseUrl)) {
+        data.notes.push(`The source \`tsconfig.base.json\` has \`baseUrl: "${baseUrl}"\`, the workspace ` +
+            `\`"${wsBase}"\`. Imports that go through the source baseUrl may not resolve.`);
+    }
+}
+//# sourceMappingURL=nx-workspace.js.map