@mouryaamit/nx-polystack 1.1.0 → 1.2.0

package/dist/src/generators/app/from.js

@@ -0,0 +1,757 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appFromReport = exports.appFrom = exports.nameForms = exports.describeBaseApp = exports.APP_ID_RE = exports.defaultAppId = exports.APP_FROM_SKIP = 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 allowlist_1 = require("../../lib/csp/allowlist");
+const render_1 = require("../../lib/csp/render");
+const empty_1 = require("../../lib/env/empty");
+const plan_1 = require("../../lib/release/plan");
+const angular_project_1 = require("../../lib/utils/angular-project");
+const app_dir_1 = require("../../lib/utils/app-dir");
+const base_href_1 = require("../../lib/utils/base-href");
+const devkit_deps_1 = require("../../lib/utils/devkit-deps");
+const llm_block_1 = require("../../lib/utils/llm-block");
+const npm_scripts_1 = require("../../lib/utils/npm-scripts");
+const project_json_files_1 = require("../../lib/utils/project-json-files");
+const serve_port_1 = require("../../lib/utils/serve-port");
+const copy_1 = require("../migrate/copy");
+/** Not copied from the base app (on top of what git ignores). */
+exports.APP_FROM_SKIP = {
+    anyDepth: ['node_modules', '.git', '.dart_tool', '.angular', '.nx', '.gradle'],
+    topLevel: ['dist', 'www', 'build', 'coverage', 'out-tsc', 'tmp', '.idea', '.vscode', '.packages'],
+    topLevelPatterns: [/^\.flutter-plugins/],
+    paths: [
+        'ios/Pods',
+        'ios/.symlinks',
+        'ios/build',
+        'ios/Flutter/Generated.xcconfig',
+        'ios/Flutter/flutter_export_environment.sh',
+        'macos/Pods',
+        'android/build',
+        'android/app/build',
+        'android/local.properties',
+        'docs/migrations',
+    ],
+    pathPatterns: [/(^|\/)flutter\/ephemeral$/i],
+};
+const FLUTTER_EXECUTOR = plan_1.FLUTTER_BUILD_EXECUTOR;
+const DEV_NAMES = ['dev', 'development'];
+/** com.example.<name, alphanumerics only>; prefixed with "app" when it would start with a digit. */
+function defaultAppId(name) {
+    let segment = name.replace(/[^a-zA-Z0-9]/g, '').toLowerCase();
+    if (!/^[a-z]/.test(segment))
+        segment = `app${segment}`;
+    return `com.example.${segment}`;
+}
+exports.defaultAppId = defaultAppId;
+exports.APP_ID_RE = /^[a-zA-Z][a-zA-Z0-9_]*(\.[a-zA-Z][a-zA-Z0-9_]*)+$/;
+const CAPACITOR_APP_ID = /(\bappId\s*:\s*)(['"])([^'"\n]*)\2/;
+/** The app named `from`, if pstack builds it (Angular/Ionic release target, Flutter flutter-build). */
+function describeBaseApp(tree, from) {
+    const project = (0, project_json_files_1.scanProjects)(tree).find((p) => p.name === from);
+    if (!project)
+        throw new Error(`no project named "${from}" in this workspace.`);
+    const { root, json } = project;
+    const targets = (json['targets'] ?? {});
+    const tags = Array.isArray(json['tags']) ? json['tags'] : [];
+    const under = root.startsWith('apps/') ? root.slice('apps/'.length).split('/') : undefined;
+    const dir = under && under.length > 1 ? under.slice(0, -1).join('/') : undefined;
+    const found = (0, base_href_1.baseHrefTarget)(json);
+    const baseHref = Object.values(found?.target.configurations ?? {}).some((c) => c?.['baseHref'] !== undefined);
+    const release = Object.values(targets).find((t) => t.executor === angular_project_1.POLYSTACK_BUILD_EXECUTOR);
+    if (release) {
+        const type = release.options?.['type'] === 'ionic' ? 'ionic' : 'angular';
+        const configs = release.configurations ?? {};
+        const envs = Object.keys(configs);
+        const devEnv = envs.find((e) => String(configs[e]?.['env'] ?? '').toUpperCase() === 'DEV') ??
+            envs.find((e) => DEV_NAMES.includes(e)) ??
+            'dev';
+        let appId;
+        if (type === 'ionic' && tree.exists(`${root}/capacitor.config.ts`)) {
+            appId = CAPACITOR_APP_ID.exec(tree.read(`${root}/capacitor.config.ts`, 'utf-8') ?? '')?.[3];
+        }
+        const envProject = typeof release.options?.['envProject'] === 'string'
+            ? release.options['envProject']
+            : from;
+        // The release executor reads environment.<env>.ts (DEV: environment.ts or environment.dev.ts).
+        const envFiles = {};
+        for (const e of envs) {
+            const env = String(configs[e]?.['env'] ?? e).toLowerCase();
+            envFiles[e] =
+                e === devEnv || DEV_NAMES.includes(env)
+                    ? ['environment.ts', 'environment.dev.ts']
+                    : [`environment.${env}.ts`];
+        }
+        return {
+            name: from,
+            type,
+            root,
+            dir,
+            envs: devFirst(envs.includes(devEnv) ? envs : [devEnv, ...envs], devEnv),
+            devEnv,
+            baseHref,
+            tags,
+            appId,
+            envProject,
+            envFiles,
+        };
+    }
+    const flutter = Object.values(targets).some((t) => t.executor === FLUTTER_EXECUTOR);
+    if (flutter && tree.exists(`${root}/env`)) {
+        const envs = tree
+            .children(`${root}/env`)
+            .filter((f) => f.endsWith('.json'))
+            .map((f) => f.slice(0, -'.json'.length));
+        const devEnv = envs.find((e) => DEV_NAMES.includes(e)) ?? 'dev';
+        return {
+            name: from,
+            type: 'flutter',
+            root,
+            dir,
+            envs: devFirst(envs.includes(devEnv) ? envs : [devEnv, ...envs], devEnv),
+            devEnv,
+            baseHref,
+            tags,
+        };
+    }
+    throw new Error(`"${from}" is not an app pstack builds: an Angular/Ionic app with a ` +
+        `${angular_project_1.POLYSTACK_BUILD_EXECUTOR} release target, or a Flutter app with flutter-build targets ` +
+        'and an env/ folder.');
+}
+exports.describeBaseApp = describeBaseApp;
+function devFirst(envs, dev) {
+    return [dev, ...envs.filter((e) => e !== dev)];
+}
+/** kebab, snake, camel, Pascal and Title forms of a kebab-case name (unique, longest first). */
+function nameForms(name) {
+    const n = (0, devkit_1.names)(name);
+    const title = n.className.replace(/([A-Z])/g, ' $1').trim();
+    return [...new Set([name, name.replace(/-/g, '_'), n.propertyName, n.className, title])].sort((a, b) => b.length - a.length);
+}
+exports.nameForms = nameForms;
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&');
+/** `text` with `from` replaced by `to` where it is a whole path (not part of a longer name). */
+function replacePath(text, from, to) {
+    const re = new RegExp(`(?<![\\w.-])${escapeRe(from)}(?![\\w-])`, 'g');
+    return text.replace(re, to);
+}
+/** Replaces each base name form by the new one, as whole words. */
+function replaceForms(text, base, name) {
+    const from = nameForms(base);
+    const to = new Map(from.map((f) => [f, formLike(f, base, name) ?? f]));
+    let out = text;
+    for (const f of from) {
+        const re = new RegExp(`(?<![A-Za-z0-9_-])${escapeRe(f)}(?![A-Za-z0-9_-])`, 'g');
+        out = out.replace(re, to.get(f) ?? f);
+    }
+    return out;
+}
+/** The form of `name` matching `form` of `base` (kebab → kebab, Pascal → Pascal, …). */
+function formLike(form, base, name) {
+    const b = (0, devkit_1.names)(base);
+    const n = (0, devkit_1.names)(name);
+    const bTitle = b.className.replace(/([A-Z])/g, ' $1').trim();
+    const nTitle = n.className.replace(/([A-Z])/g, ' $1').trim();
+    if (form === base)
+        return name;
+    if (form === base.replace(/-/g, '_'))
+        return name.replace(/-/g, '_');
+    if (form === b.propertyName)
+        return n.propertyName;
+    // A one-word base name has the same Pascal and Title form: the files renamed this way are
+    // titles and display names, so the Title form wins.
+    if (form === bTitle)
+        return nTitle;
+    if (form === b.className)
+        return n.className;
+    return undefined;
+}
+function isBinary(buf) {
+    const n = Math.min(buf.length, 8000);
+    for (let i = 0; i < n; i++)
+        if (buf[i] === 0)
+            return true;
+    return false;
+}
+/** Files of the base app to copy, and what is left behind. */
+function listFiles(tree, root, rules) {
+    const files = [];
+    const skipped = [];
+    const secrets = [];
+    const walk = (rel) => {
+        const dir = rel ? `${root}/${rel}` : root;
+        for (const child of [...tree.children(dir)].sort()) {
+            const r = rel ? `${rel}/${child}` : child;
+            const p = `${root}/${r}`;
+            const isFile = tree.isFile(p);
+            if ((0, copy_1.shouldSkip)(r, rules)) {
+                skipped.push(isFile ? r : `${r}/`);
+                continue;
+            }
+            if (!isFile) {
+                walk(r);
+                continue;
+            }
+            if ((0, copy_1.isPossibleSecret)(r)) {
+                secrets.push(r);
+                continue;
+            }
+            files.push(r);
+        }
+    };
+    walk('');
+    const listed = (0, copy_1.gitListedFiles)(path.join(tree.root, root));
+    let ignored;
+    if (listed) {
+        const set = new Set(listed);
+        // Files only in the tree (not on disk yet) are kept.
+        ignored = (rel) => !set.has(rel) && fs.existsSync(path.join(tree.root, root, rel));
+    }
+    else {
+        const ig = gitignoreOf(tree, root);
+        ignored = (rel) => ig.ignores(rel);
+    }
+    const kept = [];
+    for (const f of files) {
+        if (ignored(f))
+            skipped.push(f);
+        else
+            kept.push(f);
+    }
+    return { files: kept, skipped: skipped.sort(), secrets };
+}
+/** The workspace and app .gitignore rules, as seen from the app folder (no git available). */
+function gitignoreOf(tree, root) {
+    const ig = (0, devkit_deps_1.createIgnore)();
+    const rootIgnore = tree.read('.gitignore', 'utf-8');
+    if (rootIgnore) {
+        // Rules anchored at the workspace root that point into the app.
+        for (const line of rootIgnore.split(/\r?\n/)) {
+            const t = line.trim();
+            if (!t || t.startsWith('#'))
+                continue;
+            if (t.startsWith('/') || t.slice(0, -1).includes('/')) {
+                const anchored = t.replace(/^\//, '');
+                const neg = anchored.startsWith('!');
+                const body = neg ? anchored.slice(1) : anchored;
+                if (body.startsWith(`${root}/`))
+                    ig.add(`${neg ? '!' : ''}/${body.slice(root.length + 1)}`);
+            }
+            else {
+                ig.add(t);
+            }
+        }
+    }
+    const own = tree.read(`${root}/.gitignore`, 'utf-8');
+    if (own)
+        ig.add(own);
+    return ig;
+}
+/**
+ * Creates the new app from the base app: copies its files and configuration under the new name,
+ * empties its environment values and sets what must differ (port, base href, appId, env set).
+ */
+function appFrom(tree, o) {
+    const label = 'app --from';
+    const base = describeBaseApp(tree, o.from);
+    const { name } = o;
+    if (!app_dir_1.NAME_RE.test(name)) {
+        throw new Error(`${label}: --name="${name}" must be kebab-case (e.g. partner-portal).`);
+    }
+    if (name === base.name)
+        throw new Error(`${label}: the new app needs a name other than "${name}".`);
+    if (!base.root.includes('/')) {
+        throw new Error(`${label}: ${base.name} sits in a top-level folder (${base.root}); copy apps that live ` +
+            'under a folder such as apps/.');
+    }
+    const dir = o.dir === '.' ? undefined : (0, app_dir_1.parseDir)(o.dir ?? base.dir, label);
+    const root = (0, app_dir_1.appRoot)(name, dir);
+    if (dir)
+        (0, app_dir_1.assertDirOutsideProjects)(tree, dir, label);
+    if (tree.exists(root))
+        throw new Error(`${label}: "${root}" already exists. Pick another --name or --dir.`);
+    const projects = (0, project_json_files_1.scanProjects)(tree);
+    if (projects.some((p) => p.name === name)) {
+        throw new Error(`${label}: a project named "${name}" already exists. Pick another --name.`);
+    }
+    if (base.envProject) {
+        const owner = projects.find((p) => Object.values((p.json['targets'] ?? {})).some((t) => t.executor === angular_project_1.POLYSTACK_BUILD_EXECUTOR && t.options?.['envProject'] === name));
+        if (owner || tree.exists(`environments/${name}`)) {
+            throw new Error(`${label}: environments/${name} is already in use` +
+                `${owner ? ` (by ${owner.name})` : ''}. Pick another --name.`);
+        }
+    }
+    // Port
+    const used = (0, serve_port_1.usedServePorts)(tree);
+    let port;
+    if (o.port !== undefined) {
+        const problem = (0, serve_port_1.portProblem)(o.port);
+        if (problem)
+            throw new Error(`${label}: ${problem}.`);
+        const owner = used.find((u) => u.port === o.port);
+        if (owner)
+            throw new Error(`${label}: port ${o.port} is used by ${owner.project}. Pick another --port.`);
+        port = o.port;
+    }
+    else {
+        port = (0, serve_port_1.nextFreePort)(used.map((u) => u.port));
+    }
+    // Environments
+    const wanted = o.envs ?? base.envs;
+    const unknown = wanted.filter((e) => !base.envs.includes(e));
+    if (unknown.length > 0) {
+        throw new Error(`${label}: ${base.name} has no environment ${unknown.join(', ')} (it has ${base.envs.join(', ')}).`);
+    }
+    const envs = base.envs.filter((e) => e === base.devEnv || wanted.includes(e));
+    const leftOut = base.envs.filter((e) => !envs.includes(e));
+    // Base href
+    let baseHref;
+    if (o.baseHref === undefined)
+        baseHref = base.baseHref ? `/${name}/` : undefined;
+    else if (o.baseHref !== null)
+        baseHref = o.baseHref;
+    if (baseHref !== undefined) {
+        try {
+            (0, base_href_1.checkBaseHref)(baseHref);
+        }
+        catch (err) {
+            throw new Error(`${label}: ${err.message}`);
+        }
+    }
+    // Capacitor appId
+    let appId;
+    if (base.type === 'ionic') {
+        appId = o.appId ?? defaultAppId(name);
+        if (!exports.APP_ID_RE.test(appId)) {
+            throw new Error(`${label}: --app-id="${appId}" is not a valid Capacitor appId (reverse-DNS, e.g. com.acme.app).`);
+        }
+        if (appId === base.appId) {
+            throw new Error(`${label}: --app-id must differ from ${base.name}'s (${appId}).`);
+        }
+    }
+    const result = {
+        base,
+        name,
+        root,
+        port,
+        baseHref,
+        appId,
+        envs,
+        leftOut,
+        copied: [],
+        envFiles: [],
+        expressions: [],
+        unkeyed: [],
+        notEmptied: [],
+        skipped: [],
+        secrets: [],
+        leftovers: [],
+        scripts: [],
+    };
+    const baseDepth = base.root.split('/').length;
+    const newDepth = root.split('/').length;
+    const oldPkg = base.type === 'flutter'
+        ? /^name:\s*([A-Za-z0-9_]+)/m.exec(tree.read(`${base.root}/pubspec.yaml`, 'utf-8') ?? '')?.[1]
+        : undefined;
+    const newPkg = name.replace(/-/g, '_');
+    const rewrite = (rel, text) => {
+        let t = text;
+        if (baseDepth !== newDepth) {
+            const fileDepth = rel.split('/').length - 1;
+            const from = baseDepth + fileDepth;
+            const re = new RegExp(`(?<![\\w./])((?:\\.\\./){${from}})(?!\\.\\./)`, 'g');
+            t = t.replace(re, '../'.repeat(newDepth + fileDepth));
+        }
+        t = replacePath(t, base.root, root);
+        if (base.envProject)
+            t = replacePath(t, `environments/${base.envProject}`, `environments/${name}`);
+        return t;
+    };
+    // Ionic native projects carry the base app's appId: added again with cap-add instead.
+    const rules = base.type === 'ionic'
+        ? { ...exports.APP_FROM_SKIP, topLevel: [...exports.APP_FROM_SKIP.topLevel, 'android', 'ios'] }
+        : exports.APP_FROM_SKIP;
+    const { files, skipped, secrets } = listFiles(tree, base.root, rules);
+    result.skipped = skipped;
+    result.secrets = secrets;
+    for (const rel of files) {
+        const src = `${base.root}/${rel}`;
+        const dest = `${root}/${rel}`;
+        const mode = fileMode(tree, src);
+        // Flutter env files: only the kept ones, every value emptied.
+        if (base.type === 'flutter' && /^env\/[^/]+\.json$/.test(rel)) {
+            const env = rel.slice('env/'.length, -'.json'.length);
+            if (!envs.includes(env))
+                continue;
+            let json;
+            try {
+                json = JSON.parse(tree.read(src, 'utf-8') ?? '{}');
+            }
+            catch (err) {
+                throw new Error(`${label}: ${src} is not valid JSON: ${err.message}`);
+            }
+            tree.write(dest, JSON.stringify((0, empty_1.emptyJson)(json), null, 2) + '\n');
+            result.envFiles.push(dest);
+            continue;
+        }
+        const buf = tree.read(src);
+        if (!buf)
+            continue;
+        if (isBinary(buf)) {
+            tree.write(dest, buf, mode !== undefined ? { mode } : undefined);
+            result.copied.push(dest);
+            continue;
+        }
+        let text = rewrite(rel, buf.toString('utf-8'));
+        const file = rel.split('/').pop() ?? rel;
+        if (rel === 'project.json') {
+            text = projectJson(text, base, o, result);
+        }
+        else if (rel === 'src/index.html' ||
+            rel === 'web/index.html' ||
+            rel === 'web/manifest.json') {
+            text = replaceForms(text, base.name, name);
+        }
+        else if (rel === 'capacitor.config.ts') {
+            text = text.replace(CAPACITOR_APP_ID, (_m, pre, q) => `${pre}${q}${appId}${q}`);
+            text = text.replace(/(\bappName\s*:\s*)(['"])([^'"\n]*)\2/, (m, pre, q, v) => `${pre}${q}${replaceForms(v, base.name, name)}${q}`);
+        }
+        else if (rel === 'package.json' && base.type === 'ionic') {
+            text = text.replace(/("name"\s*:\s*")([^"]*)"/, (_m, pre, v) => `${pre}${v === base.name || v.startsWith(`${base.name}-`) ? name + v.slice(base.name.length) : v}"`);
+        }
+        else if (rel === 'pubspec.yaml' && oldPkg) {
+            text = text.replace(/^name:\s*[A-Za-z0-9_]+/m, `name: ${newPkg}`);
+        }
+        else if (rel === 'csp-allowlist.json' && o.csp === 'clear') {
+            let permissionsPolicy;
+            try {
+                permissionsPolicy = (0, allowlist_1.parseAllowlist)(JSON.parse(text)).permissionsPolicy;
+            }
+            catch {
+                permissionsPolicy = undefined;
+            }
+            const cleared = (0, allowlist_1.parseAllowlist)({});
+            text = (0, allowlist_1.serializeAllowlist)(permissionsPolicy ? { ...cleared, permissionsPolicy } : cleared);
+        }
+        if (oldPkg && file.endsWith('.dart')) {
+            text = text.replace(new RegExp(`(['"])package:${escapeRe(oldPkg)}/`, 'g'), `$1package:${newPkg}/`);
+        }
+        tree.write(dest, text, mode !== undefined ? { mode } : undefined);
+        result.copied.push(dest);
+    }
+    // Angular/Ionic env files live in environments/<envProject>/.
+    if (base.envProject)
+        copyAngularEnvFiles(tree, base, name, result);
+    // Server configs written by pstack: render them again for the new app.
+    if (base.type !== 'flutter') {
+        let allowlist;
+        try {
+            allowlist = (0, allowlist_1.parseAllowlist)(JSON.parse(tree.read(`${root}/csp-allowlist.json`, 'utf-8') ?? '{}'));
+        }
+        catch {
+            allowlist = undefined;
+        }
+        if (allowlist) {
+            for (const [file, render] of [
+                [`${root}/src/.htaccess`, render_1.renderHtaccess],
+                [`${root}/server/nginx.conf`, render_1.renderNginx],
+            ]) {
+                if (tree.exists(file) && (tree.read(file, 'utf-8') ?? '').includes(render_1.GENERATED_MARKER)) {
+                    tree.write(file, render(name, allowlist));
+                }
+            }
+        }
+    }
+    copyEncryptionKeys(tree, base, name);
+    copyTsPaths(tree, base, name, root);
+    result.scripts = copyNpmScripts(tree, base, name, leftOut);
+    result.leftovers = findLeftovers(tree, base.name, [...result.copied, ...result.envFiles]);
+    (0, llm_block_1.refreshLlmBlocks)(tree);
+    return result;
+}
+exports.appFrom = appFrom;
+function fileMode(tree, rel) {
+    try {
+        const stat = fs.statSync(path.join(tree.root, rel));
+        return stat.mode & 0o777;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The new project.json: renamed, env set trimmed, port, base href, no domain lock. */
+function projectJson(text, base, o, r) {
+    let json;
+    try {
+        json = JSON.parse(text);
+    }
+    catch (err) {
+        throw new Error(`app --from: ${base.root}/project.json is not valid JSON: ${err.message}`);
+    }
+    json = renameTargets(json, base.name, r.name);
+    json['name'] = r.name;
+    if (typeof json['$schema'] === 'string') {
+        json['$schema'] = `${(0, app_dir_1.upTo)(r.root)}node_modules/nx/schemas/project-schema.json`;
+    }
+    if (o.tags)
+        json['tags'] = o.tags;
+    const targets = (json['targets'] ?? {});
+    for (const t of Object.values(targets)) {
+        if (t.executor !== angular_project_1.POLYSTACK_BUILD_EXECUTOR)
+            continue;
+        t.options ??= {};
+        if (base.envProject)
+            t.options['envProject'] = r.name;
+        for (const c of [t.options, ...Object.values(t.configurations ?? {})]) {
+            delete c['domains'];
+            delete c['includeWww'];
+        }
+    }
+    for (const env of r.leftOut) {
+        if (base.type === 'flutter') {
+            for (const t of Object.values(targets)) {
+                if (t.executor !== FLUTTER_EXECUTOR || !t.configurations)
+                    continue;
+                for (const [k, c] of Object.entries(t.configurations)) {
+                    if (k === env || c?.['env'] === env)
+                        delete t.configurations[k];
+                }
+            }
+            continue;
+        }
+        for (const t of Object.values(targets)) {
+            if (t.executor !== angular_project_1.POLYSTACK_BUILD_EXECUTOR || !t.configurations)
+                continue;
+            const key = (0, plan_1.configurationFor)(t, env);
+            if (!key)
+                continue;
+            const buildConf = t.configurations[key]?.['buildConfiguration'] ??
+                { prod: 'production', uat: 'uat' }[env] ??
+                env;
+            delete t.configurations[key];
+            const buildRef = t.options?.['buildTarget'];
+            const buildName = typeof buildRef === 'string' && buildRef.startsWith(`${r.name}:`)
+                ? buildRef.split(':')[1]
+                : 'build';
+            const build = targets[buildName];
+            if (build?.configurations?.[buildConf])
+                delete build.configurations[buildConf];
+            for (const s of Object.values(targets)) {
+                if (!s.configurations)
+                    continue;
+                for (const [k, c] of Object.entries(s.configurations)) {
+                    const ref = c?.['browserTarget'] ?? c?.['buildTarget'];
+                    if (typeof ref === 'string' && ref === `${r.name}:${buildName}:${buildConf}`) {
+                        delete s.configurations[k];
+                        if (s.defaultConfiguration === k)
+                            delete s.defaultConfiguration;
+                    }
+                }
+            }
+        }
+    }
+    // A default configuration that was left out would make `nx build <app>` fail.
+    for (const t of Object.values(targets)) {
+        if (t.defaultConfiguration && !t.configurations?.[t.defaultConfiguration]) {
+            delete t.defaultConfiguration;
+        }
+    }
+    const serve = (0, serve_port_1.serveTargetOf)(json);
+    if (serve)
+        serve.options = { ...(serve.options ?? {}), port: r.port };
+    const found = (0, base_href_1.baseHrefTarget)(json);
+    if (found) {
+        const configs = found.target.configurations ?? {};
+        const withHref = Object.keys(configs).filter((k) => configs[k]?.['baseHref'] !== undefined);
+        const targetsOf = withHref.length > 0 ? withHref : ['uat', 'prod'].filter((k) => configs[k] !== undefined);
+        if (r.baseHref !== undefined)
+            (0, base_href_1.setBaseHref)(found.target, targetsOf, r.baseHref);
+        else if (withHref.length > 0)
+            (0, base_href_1.setBaseHref)(found.target, withHref, undefined);
+    }
+    return JSON.stringify(json, null, 2) + '\n';
+}
+/** Every string with `<base>:` (a target reference) or `nx … <base>` turned to the new name. */
+function renameTargets(value, base, name) {
+    if (typeof value === 'string') {
+        return value
+            .replace(new RegExp(`(^|[\\s'"=])${escapeRe(base)}:`, 'g'), `$1${name}:`)
+            .replace(new RegExp(`(\\bnx\\s+(?:run|serve|build|test|lint|export|e2e)\\s+)${escapeRe(base)}(?![\\w-])`, 'g'), `$1${name}`);
+    }
+    if (Array.isArray(value))
+        return value.map((v) => renameTargets(v, base, name));
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, renameTargets(v, base, name)]));
+    }
+    return value;
+}
+/** environments/<base>/ → environments/<name>/: the kept envs, every value emptied. */
+function copyAngularEnvFiles(tree, base, name, r) {
+    const from = `environments/${base.envProject}`;
+    if (!tree.exists(from))
+        return;
+    const leftOutFiles = new Set(r.leftOut.flatMap((e) => base.envFiles?.[e] ?? []));
+    for (const file of [...tree.children(from)].sort()) {
+        const src = `${from}/${file}`;
+        if (!tree.isFile(src))
+            continue;
+        const dest = `environments/${name}/${file}`;
+        if (leftOutFiles.has(file))
+            continue;
+        const text = tree.read(src, 'utf-8') ?? '';
+        // Helper files (types, shared parts) are copied as they are.
+        if (!/\benvironment\b\s*(?::[^=]*)?=/.test(text)) {
+            tree.write(dest, text);
+            r.copied.push(dest);
+            continue;
+        }
+        if (!/\benvironment\b\s*(?::[^=]*)?=\s*\{/.test(text)) {
+            tree.write(dest, text);
+            r.copied.push(dest);
+            r.notEmptied.push(dest);
+            continue;
+        }
+        const emptied = (0, empty_1.emptyEnvironmentText)(text);
+        tree.write(dest, emptied.text);
+        r.envFiles.push(dest);
+        r.expressions.push(...emptied.expressions.map((k) => `${dest}: ${k}`));
+        r.unkeyed.push(...emptied.unkeyed.map((k) => `${dest}: ${k}`));
+    }
+}
+/** nx.json pstack.envEncryption.keys.<base> (key names only) → keys.<name>. */
+function copyEncryptionKeys(tree, base, name) {
+    if (!base.envProject || !tree.exists('nx.json'))
+        return;
+    const keys = (0, devkit_1.readJson)(tree, 'nx.json').pstack?.envEncryption?.keys;
+    const list = keys?.[base.envProject];
+    if (!Array.isArray(list) || keys?.[name])
+        return;
+    (0, devkit_1.updateJson)(tree, 'nx.json', (json) => {
+        json.pstack.envEncryption.keys[name] = [...list];
+        return json;
+    });
+}
+/** tsconfig.base.json aliases that point into the base app, for the new app. */
+function copyTsPaths(tree, base, name, root) {
+    if (!tree.exists('tsconfig.base.json'))
+        return;
+    (0, devkit_1.updateJson)(tree, 'tsconfig.base.json', (json) => {
+        const opts = (json['compilerOptions'] ?? {});
+        const paths = (opts['paths'] ?? {});
+        for (const [alias, targets] of Object.entries({ ...paths })) {
+            if (!Array.isArray(targets) || targets.length === 0)
+                continue;
+            const inside = targets.every((t) => t === base.root || t.startsWith(`${base.root}/`));
+            if (!inside)
+                continue;
+            const next = replaceForms(alias, base.name, name);
+            if (next === alias || paths[next])
+                continue;
+            paths[next] = targets.map((t) => root + t.slice(base.root.length));
+        }
+        return json;
+    });
+}
+/** Root npm scripts of the base app (`serve:web`, `build:web:uat`, …) for the new app. */
+function copyNpmScripts(tree, base, name, leftOut) {
+    if (!tree.exists('package.json'))
+        return [];
+    const scripts = ((0, devkit_1.readJson)(tree, 'package.json').scripts ?? {});
+    const add = {};
+    for (const [key, cmd] of Object.entries(scripts)) {
+        // <verb>:<app>[:<env>…]: only the app segment is the app's name.
+        const parts = key.split(':');
+        if (parts[1] !== base.name)
+            continue;
+        if (parts.slice(2).some((p) => leftOut.includes(p)))
+            continue;
+        const newKey = [parts[0], name, ...parts.slice(2)].join(':');
+        if (scripts[newKey] !== undefined)
+            continue;
+        add[newKey] = renameTargets(cmd, base.name, name);
+    }
+    if (Object.keys(add).length > 0)
+        (0, npm_scripts_1.addNpmScripts)(tree, add, { force: false });
+    return Object.keys(add);
+}
+const MAX_LEFTOVERS = 50;
+/** Lines of the written text files that still name the base app. */
+function findLeftovers(tree, base, files) {
+    const forms = nameForms(base);
+    const re = new RegExp(`(?<![A-Za-z0-9_-])(${forms.map(escapeRe).join('|')})(?![A-Za-z0-9_-])`);
+    const out = [];
+    for (const file of files) {
+        const buf = tree.read(file);
+        if (!buf || isBinary(buf))
+            continue;
+        const lines = buf.toString('utf-8').split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            if (re.test(lines[i])) {
+                out.push({ file, line: i + 1, text: lines[i].trim().slice(0, 120) });
+                if (out.length >= MAX_LEFTOVERS)
+                    return out;
+            }
+        }
+    }
+    return out;
+}
+/** The report printed after (or, with --dry-run, instead of) creating the app. */
+function appFromReport(r) {
+    const lines = [];
+    lines.push(`${r.name} (${r.root}) from ${r.base.name}: ${r.copied.length} file(s) copied, ` +
+        `${r.envFiles.length} env file(s) with every value emptied.`);
+    lines.push(`  port ${r.port}${r.baseHref ? `, base href ${r.baseHref}` : ''}${r.appId ? `, appId ${r.appId}` : ''}`);
+    lines.push(`  environments: ${r.envs.join(', ')}${r.leftOut.length ? ` (left out: ${r.leftOut.join(', ')})` : ''}`);
+    if (r.scripts.length > 0)
+        lines.push(`  npm scripts: ${r.scripts.join(', ')}`);
+    if (r.expressions.length > 0) {
+        lines.push('  Values that were not literals, now empty strings:');
+        for (const e of r.expressions)
+            lines.push(`    ${e}`);
+    }
+    if (r.notEmptied.length > 0) {
+        lines.push('  NOT emptied (the environment is not an object literal; values copied as they are):');
+        for (const e of r.notEmptied)
+            lines.push(`    ${e}`);
+    }
+    if (r.unkeyed.length > 0) {
+        lines.push('  Entries left as written (spread / shorthand):');
+        for (const e of r.unkeyed)
+            lines.push(`    ${e}`);
+    }
+    if (r.secrets.length > 0)
+        lines.push(`  Not copied (possible secrets): ${r.secrets.join(', ')}`);
+    if (r.skipped.length > 0) {
+        const shown = r.skipped.slice(0, 20);
+        lines.push(`  Not copied (build output, caches, ignored files): ${shown.join(', ')}` +
+            (r.skipped.length > shown.length ? `, … (${r.skipped.length - shown.length} more)` : ''));
+    }
+    if (r.leftovers.length > 0) {
+        lines.push(`  Still naming ${r.base.name} (review these):`);
+        for (const l of r.leftovers)
+            lines.push(`    ${l.file}:${l.line}  ${l.text}`);
+        if (r.leftovers.length >= MAX_LEFTOVERS)
+            lines.push('    … (first 50 shown)');
+    }
+    lines.push('Next:');
+    lines.push(`  - fill in the env files (every value is empty, production is false): ${r.base.type === 'flutter' ? `${r.root}/env/*.json` : `environments/${r.name}/`}`);
+    if (r.base.type !== 'flutter') {
+        lines.push(`  - encrypted keys and domain locks: pstack encryption --app=${r.name} --domains=<env>=<hosts>`);
+    }
+    if (r.base.type === 'flutter' &&
+        r.copied.some((f) => f.startsWith(`${r.root}/android/`) || f.startsWith(`${r.root}/ios/`))) {
+        lines.push(`  - android/ and ios/ still use ${r.base.name}'s applicationId / bundle id: change them ` +
+            `before installing ${r.name} next to ${r.base.name}`);
+    }
+    if (r.base.type === 'ionic' && r.skipped.some((s) => s === 'android/' || s === 'ios/')) {
+        lines.push(`  - native projects were not copied (they hold ${r.base.name}'s appId): ` +
+            `nx run ${r.name}:cap-add --platform=android|ios`);
+    }
+    lines.push(`  - nx run ${r.name}:serve`);
+    return lines.join('\n');
+}
+exports.appFromReport = appFromReport;
+//# sourceMappingURL=from.js.map