@jayree/sfdx-plugin-manifest 2.9.1 → 3.0.1

package/lib/commands/jayree/manifest/git/diff.js

@@ -4,179 +4,108 @@
  * Licensed under the BSD 3-Clause license.
  * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
  */
-import { join, basename, sep, posix, dirname, relative, resolve } from 'node:path';
+import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { format } from 'node:util';
-import { SfCommand, Flags, arrayWithDeprecation } from '@salesforce/sf-plugins-core';
-import { Messages, SfError, SfProject } from '@salesforce/core';
-import { Args } from '@oclif/core';
+import { Messages } from '@salesforce/core';
 import fs from 'fs-extra';
-import { Logger, Listr } from 'listr2';
-import { env } from '@salesforce/kit';
+import { DestructiveChangesType } from '@salesforce/source-deploy-retrieve';
+import { SfCommand, Flags, orgApiVersionFlagWithDeprecations, arrayWithDeprecation } from '@salesforce/sf-plugins-core';
+import { Args } from '@oclif/core';
 import { getString } from '@salesforce/ts-types';
-import equal from 'fast-deep-equal';
-import { ComponentSet, RegistryAccess, registry, VirtualTreeContainer, MetadataResolver, DestructiveChangesType, } from '@salesforce/source-deploy-retrieve';
-import { parseMetadataXml } from '@salesforce/source-deploy-retrieve/lib/src/utils/index.js';
-import Debug from 'debug';
-import git from 'isomorphic-git';
+import { ComponentSetExtra } from '../../../../SDR-extra/index.js';
 // eslint-disable-next-line no-underscore-dangle
 const __filename = fileURLToPath(import.meta.url);
 // eslint-disable-next-line no-underscore-dangle
 const __dirname = dirname(__filename);
 Messages.importMessagesDirectory(__dirname);
 const messages = Messages.loadMessages('@jayree/sfdx-plugin-manifest', 'gitdiff');
-const logger = new Logger({ useIcons: false });
-const debug = Debug('jayree:manifest:git:diff');
-const registryAccess = new RegistryAccess();
-export default class GitDiff extends SfCommand {
+export default class GitDiffCommand extends SfCommand {
+    // eslint-disable-next-line sf-plugin/should-parse-flags
     async run() {
-        const { flags, args } = await this.parse(GitDiff);
-        const sourcepath = flags['source-dir'];
-        this.destructiveChangesOnly = flags['destructive-changes-only'];
+        await this.createManifest();
+        return this.formatResult();
+    }
+    async getSourceApiVersion() {
+        const projectConfig = await this.project.resolveProjectConfig();
+        return getString(projectConfig, 'sourceApiVersion') ?? undefined;
+    }
+    async createManifest() {
+        const { flags, args } = await this.parse(GitDiffCommand);
+        this.manifestName = 'package.xml';
+        this.destructiveChangesName = 'destructiveChanges.xml';
         this.outputDir = flags['output-dir'];
-        this.projectRoot = this.project.getPath();
-        this.sourceApiVersion = (await this.getSourceApiVersion());
-        this.destructiveChanges = join(this.outputDir, 'destructiveChanges.xml');
-        this.manifest = join(this.outputDir, 'package.xml');
-        debug({
-            outputDir: this.outputDir,
-            projectRoot: this.projectRoot,
+        this.destructiveChangesOnly = flags['destructive-changes-only'];
+        this.componentSet = await ComponentSetExtra.fromGitDiff({
+            ref: [args.ref1, args.ref2],
+            fsPaths: flags['source-dir'],
         });
-        const isContentTypeJSON = env.getString('SFDX_CONTENT_TYPE', '').toUpperCase() === 'JSON';
-        this.isOutputEnabled = !(this.argv.find((arg) => arg === '--json') ?? isContentTypeJSON);
-        const gitArgs = await getGitArgsFromArgv(args.ref1, args.ref2, this.argv, this.projectRoot);
-        debug({ gitArgs });
-        const tasks = new Listr([
-            {
-                title: `Execute 'git --no-pager diff --name-status --no-renames ${gitArgs.refString}'`,
-                task: async (ctx, task) => {
-                    const { gitlines, warnings } = await getGitDiff(gitArgs.ref1, gitArgs.ref2, this.projectRoot);
-                    this.gitLines = gitlines;
-                    this.outputWarnings = warnings;
-                    task.output = `Changed files: ${this.gitLines.length}`;
-                },
-                options: { persistentOutput: true },
-            },
-            {
-                // title: 'Warning output',
-                skip: () => !this.outputWarnings?.length,
-                task: (ctx, task) => {
-                    debug({ warnings: this.outputWarnings });
-                    const moreWarnings = this.outputWarnings.splice(5);
-                    for (const message of this.outputWarnings) {
-                        task.output = `Warning: unstaged file ${message}`;
-                    }
-                    task.output = moreWarnings.length ? `... ${moreWarnings.length} more warnings` : '';
-                },
-                options: { persistentOutput: true, bottomBar: 6 },
-            },
-            {
-                title: 'Create virtual tree container',
-                skip: () => !this.gitLines.length,
-                task: (ctx, task) => task.newListr([
-                    {
-                        title: `ref1: ${gitArgs.ref1}`,
-                        task: async () => {
-                            this.ref1VirtualTreeContainer = await createVirtualTreeContainer(gitArgs.ref1, this.projectRoot, this.gitLines.filter((l) => l.status === 'M').map((l) => l.path));
-                        },
-                    },
-                    {
-                        title: gitArgs.ref2 !== '' ? `ref2: ${gitArgs.ref2}` : 'ref2: (staging area)',
-                        task: async () => {
-                            this.ref2VirtualTreeContainer = await createVirtualTreeContainer(gitArgs.ref2, this.projectRoot, this.gitLines.filter((l) => l.status === 'M').map((l) => l.path));
-                        },
-                    },
-                ], { concurrent: true }),
-            },
-            {
-                title: 'Analyze git diff results',
-                skip: () => !this.gitLines.length,
-                task: async (ctx, task) => {
-                    if (sourcepath) {
-                        this.fsPaths = sourcepath.map((filepath) => {
-                            filepath = resolve(filepath);
-                            if (!this.ref1VirtualTreeContainer.exists(filepath) &&
-                                !this.ref2VirtualTreeContainer.exists(filepath)) {
-                                throw new SfError(`The sourcepath "${filepath}" is not a valid source file path.`);
-                            }
-                            return filepath;
-                        });
-                        debug(`fsPaths: ${this.fsPaths.join(', ')}`);
+        this.componentSet.sourceApiVersion = flags['api-version'] ?? (await this.getSourceApiVersion());
+        if (this.outputDir) {
+            await fs.ensureDir(this.outputDir);
+            this.outputPath = join(this.outputDir, this.manifestName);
+        }
+        else {
+            this.outputPath = this.manifestName;
+        }
+        if (this.componentSet.size) {
+            if (this.componentSet.getTypesOfDestructiveChanges().length) {
+                await fs.writeFile(join(this.outputDir, this.destructiveChangesName), await this.componentSet.getPackageXml(undefined, DestructiveChangesType.POST));
+            }
+            if (this.destructiveChangesOnly) {
+                if (this.componentSet.getTypesOfDestructiveChanges().length) {
+                    const emptyCompSet = new ComponentSetExtra();
+                    emptyCompSet.sourceApiVersion = this.componentSet.sourceApiVersion;
+                    return fs.writeFile(this.outputPath, await emptyCompSet.getPackageXml());
+                }
+                return;
+            }
+            return fs.writeFile(this.outputPath, await this.componentSet.getPackageXml());
+        }
+    }
+    formatResult() {
+        if (!this.jsonEnabled()) {
+            if (this.componentSet.size) {
+                if (this.destructiveChangesOnly && !this.componentSet.getTypesOfDestructiveChanges().length) {
+                    this.log(messages.getMessage('noComponents'));
+                }
+                else if (this.outputDir) {
+                    this.log(messages.getMessage('successOutputDir', [this.manifestName, this.outputDir]));
+                    if (this.componentSet.getTypesOfDestructiveChanges().length) {
+                        this.log(messages.getMessage('successOutputDir', [this.destructiveChangesName, this.outputDir]));
                     }
-                    const { manifest, output } = await getGitResults(this.gitLines, this.ref1VirtualTreeContainer, this.ref2VirtualTreeContainer, this.destructiveChangesOnly, this.fsPaths);
-                    task.output = `Added: ${output.counts.added}, Deleted: ${output.counts.deleted}, Modified: ${output.counts.modified}, Unchanged: ${output.counts.unchanged}, Ignored: ${output.counts.ignored}${output.counts.error ? `, Errors: ${output.counts.error}` : ''}`;
-                    this.outputErrors = output.errors;
-                    debug({ manifest });
-                    this.componentSet = fixComponentSetChilds(manifest);
-                    this.componentSet.sourceApiVersion = this.sourceApiVersion;
-                },
-                options: { persistentOutput: true },
-            },
-            {
-                // title: 'Error output',
-                skip: () => !this.outputErrors?.length,
-                task: (ctx, task) => {
-                    debug({ errors: this.outputErrors });
-                    const moreErrors = this.outputErrors.splice(5);
-                    for (const message of this.outputErrors) {
-                        task.output = `Error: ${message}`;
+                }
+                else {
+                    this.log(messages.getMessage('success', [this.manifestName]));
+                    if (this.componentSet.getTypesOfDestructiveChanges().length) {
+                        this.log(messages.getMessage('success', [this.destructiveChangesName]));
                     }
-                    task.output = moreErrors.length ? `... ${moreErrors.length} more errors` : '';
-                },
-                options: { persistentOutput: true, bottomBar: 6 },
-            },
-            {
-                title: 'Generate manifests',
-                skip: () => !this.componentSet?.size,
-                task: (ctx, task) => task.newListr([
-                    {
-                        title: this.manifest,
-                        skip: () => !this.isOutputEnabled,
-                        task: async () => {
-                            await fs.ensureDir(dirname(this.manifest));
-                            await fs.writeFile(this.manifest, await this.componentSet.getPackageXml());
-                        },
-                        options: { persistentOutput: true },
-                    },
-                    {
-                        title: this.destructiveChanges,
-                        skip: () => !this.componentSet.getTypesOfDestructiveChanges().length || !this.isOutputEnabled,
-                        task: async () => {
-                            await fs.ensureDir(dirname(this.destructiveChanges));
-                            await fs.writeFile(this.destructiveChanges, await this.componentSet.getPackageXml(undefined, DestructiveChangesType.POST));
-                        },
-                        options: { persistentOutput: true },
-                    },
-                ], { concurrent: true }),
-            },
-        ], {
-            rendererOptions: { showTimer: true, collapse: false, lazy: true, collapseErrors: false },
-            rendererSilent: !this.isOutputEnabled,
-            rendererFallback: debug.enabled,
-        });
-        try {
-            await tasks.run();
+                }
+            }
+            else {
+                this.log(messages.getMessage('noComponents'));
+            }
+        }
+        if (this.componentSet.getTypesOfDestructiveChanges().length) {
             return {
-                destructiveChanges: await this.componentSet?.getObject(DestructiveChangesType.POST),
-                manifest: await this.componentSet?.getObject(),
+                manifest: { path: this.outputPath, name: this.manifestName },
+                destructiveChanges: {
+                    path: join(this.outputDir, this.destructiveChangesName),
+                    name: this.destructiveChangesName,
+                },
             };
         }
-        catch (e) {
-            if (debug.enabled && this.isOutputEnabled) {
-                logger.fail(e.message);
-            }
-            throw e;
+        else if (this.componentSet.size && !this.destructiveChangesOnly) {
+            return { manifest: { path: this.outputPath, name: this.manifestName } };
+        }
+        else {
+            return {};
         }
-    }
-    async getSourceApiVersion() {
-        const projectConfig = await this.project.resolveProjectConfig();
-        return getString(projectConfig, 'sourceApiVersion') ?? undefined;
     }
 }
-GitDiff.summary = messages.getMessage('summary');
-GitDiff.description = messages.getMessage('description');
-GitDiff.examples = messages.getMessages('examples');
-GitDiff.args = {
+GitDiffCommand.summary = messages.getMessage('summary');
+GitDiffCommand.description = messages.getMessage('description');
+GitDiffCommand.examples = messages.getMessages('examples');
+GitDiffCommand.args = {
     ref1: Args.string({
         required: true,
         description: messages.getMessage('args.ref1.description'),
@@ -185,8 +114,11 @@ GitDiff.args = {
         description: messages.getMessage('args.ref2.description'),
     }),
 };
-GitDiff.requiresProject = true;
-GitDiff.flags = {
+GitDiffCommand.requiresProject = true;
+GitDiffCommand.deprecateAliases = true;
+GitDiffCommand.aliases = ['jayree:manifest:beta:git:diff'];
+GitDiffCommand.flags = {
+    'api-version': orgApiVersionFlagWithDeprecations,
     'source-dir': arrayWithDeprecation({
         char: 'd',
         summary: messages.getMessage('flags.source-dir.summary'),
@@ -208,433 +140,4 @@ GitDiff.flags = {
         aliases: ['destructivechangesonly'],
     }),
 };
-async function resolveRef(refOrig, dir) {
-    if (refOrig === '') {
-        return '';
-    }
-    const getCommitLog = async (ref) => {
-        try {
-            const [log] = await git.log({
-                fs,
-                dir,
-                ref,
-                depth: 1,
-            });
-            return { oid: log.oid, parents: log.commit.parent };
-        }
-        catch (error) {
-            throw new Error(`ambiguous argument '${ref}': unknown revision or path not in the working tree.
-See more help with --help`);
-        }
-    };
-    if (!['~', '^'].some((el) => refOrig.includes(el))) {
-        return (await getCommitLog(refOrig)).oid;
-    }
-    const firstIndex = [refOrig.indexOf('^'), refOrig.indexOf('~')]
-        .filter((a) => a >= 0)
-        .reduce((a, b) => Math.min(a, b));
-    let path = refOrig.substring(firstIndex);
-    let ref = refOrig.substring(0, firstIndex);
-    while (path.length && ref !== undefined) {
-        if (path.startsWith('^')) {
-            path = path.substring(1);
-            let next = Number(path.substring(0, 1));
-            path = next ? path.substring(1) : path;
-            next = next ? next : 1;
-            // eslint-disable-next-line no-await-in-loop
-            ref = (await getCommitLog(ref)).parents[next - 1];
-        }
-        else if (path.startsWith('~')) {
-            path = path.substring(1);
-            let next = Number(path.substring(0, 1));
-            path = next ? path.substring(1) : path;
-            next = next ? next : 1;
-            for (let index = 0; index <= next - 1; index++) {
-                // eslint-disable-next-line no-await-in-loop
-                ref = (await getCommitLog(ref)).parents[0];
-            }
-        }
-        else {
-            ref = undefined;
-        }
-    }
-    if (ref === undefined) {
-        throw new Error(`ambiguous argument '${refOrig}': unknown revision or path not in the working tree.`);
-    }
-    return ref;
-}
-async function getGitArgsFromArgv(ref1, ref2, argv, dir) {
-    const newArgv = [];
-    while (argv.length) {
-        let [e] = argv.splice(0, 1);
-        if (e.includes('=')) {
-            // skip parameter=value
-        }
-        else if (e.includes('-')) {
-            // remove value
-            if (argv[0] && !argv[0].includes('-') && ![ref1, ref2].includes(argv[0])) {
-                [e] = argv.splice(0, 1);
-            }
-        }
-        else {
-            newArgv.push(e);
-        }
-    }
-    argv = newArgv;
-    let refString = ref1;
-    const a = argv.join('.').split('.');
-    if ((a.length === 3 || a.length === 4) && typeof ref2 === 'undefined') {
-        ref1 = a[0];
-        ref2 = a[a.length - 1];
-    }
-    else if (a.length === 2 && typeof ref2 !== 'undefined') {
-        refString = `${ref1}..${ref2}`;
-    }
-    else if (a.length === 1) {
-        ref2 = '';
-    }
-    else {
-        throw new Error(`Ambiguous ${format('argument%s', argv.length === 1 ? '' : 's')}: ${argv.join(', ')}
-See more help with --help`);
-    }
-    ref1 = await resolveRef(ref1, dir);
-    ref2 = await resolveRef(ref2, dir);
-    if (a.length === 4) {
-        ref1 = (await git.findMergeBase({
-            fs,
-            dir,
-            oids: [ref2, ref1],
-        }))[0];
-    }
-    return { ref1, ref2, refString };
-}
-function ensureOSPath(path) {
-    return path.split(posix.sep).join(sep);
-}
-function ensureGitRelPath(dir, path) {
-    return relative(dir, path).split(sep).join(posix.sep);
-}
-async function createVirtualTreeContainer(ref, dir, modifiedFiles) {
-    const paths = (await git.listFiles({ fs, dir, ref })).map((p) => join(dir, ensureOSPath(p)));
-    const oid = ref ? await git.resolveRef({ fs, dir, ref }) : '';
-    const virtualDirectoryByFullPath = new Map();
-    for await (const filename of paths) {
-        let dirPath = dirname(filename);
-        virtualDirectoryByFullPath.set(dirPath, {
-            dirPath,
-            children: Array.from(new Set(virtualDirectoryByFullPath.get(dirPath)?.children ?? []).add({
-                name: basename(filename),
-                data: parseMetadataXml(filename) && modifiedFiles.includes(filename)
-                    ? oid
-                        ? Buffer.from((await git.readBlob({ fs, dir, oid, filepath: ensureGitRelPath(dir, filename) })).blob)
-                        : await fs.readFile(ensureOSPath(filename))
-                    : Buffer.from(''),
-            })),
-        });
-        const splits = filename.split(sep);
-        for (let i = 1; i < splits.length - 1; i++) {
-            dirPath = splits.slice(0, i + 1).join(sep);
-            virtualDirectoryByFullPath.set(dirPath, {
-                dirPath,
-                children: Array.from(new Set(virtualDirectoryByFullPath.get(dirPath)?.children ?? []).add(splits[i + 1])),
-            });
-        }
-    }
-    return new VirtualTreeContainer(Array.from(virtualDirectoryByFullPath.values()));
-}
-async function analyzeFile(path, ref1VirtualTreeContainer, ref2VirtualTreeContainer) {
-    if (!parseMetadataXml(path)) {
-        return { path, status: 0 };
-    }
-    const ref2resolver = new MetadataResolver(registryAccess, ref2VirtualTreeContainer);
-    const [ref2Component] = ref2resolver.getComponentsFromPath(path); // git path only conaints files
-    const ref1resolver = new MetadataResolver(registryAccess, ref1VirtualTreeContainer);
-    const [ref1Component] = ref1resolver.getComponentsFromPath(path); // git path only conaints files
-    if (ref1resolver.forceIgnoredPaths.has(path) || ref2resolver.forceIgnoredPaths.has(path)) {
-        return { path, status: -2 };
-    }
-    if (equal(await ref1Component.parseXml(), await ref2Component.parseXml())) {
-        return { path, status: -1 };
-    }
-    if (ref1Component.type.strictDirectoryName === true || !ref1Component.type.children) {
-        return { path, status: 0 };
-    }
-    const ref2ChildUniqueIdArray = ref2Component
-        .getChildren()
-        .map((childComponent) => getUniqueIdentifier(childComponent));
-    const ref1ChildUniqueIdArray = ref1Component
-        .getChildren()
-        .map((childComponent) => getUniqueIdentifier(childComponent));
-    const childComponentsNotInRef2 = ref1Component
-        .getChildren()
-        .filter((childComponent) => !ref2ChildUniqueIdArray.includes(getUniqueIdentifier(childComponent))); // deleted
-    const childComponentsNotInRef1 = ref2Component
-        .getChildren()
-        .filter((childComponent) => !ref1ChildUniqueIdArray.includes(getUniqueIdentifier(childComponent))); // added
-    const childComponentsInRef1AndRef2 = ref1Component
-        .getChildren()
-        .filter((childComponent) => ref2ChildUniqueIdArray.includes(getUniqueIdentifier(childComponent))); // modified?
-    debug({ childComponentsNotInRef2, childComponentsNotInRef1, childComponentsInRef1AndRef2 });
-    for await (const childComponentRef1 of childComponentsInRef1AndRef2) {
-        const [childComponentRef2] = ref2Component
-            .getChildren()
-            .filter((childComponent) => getUniqueIdentifier(childComponentRef1) === getUniqueIdentifier(childComponent));
-        if (!equal(await childComponentRef1.parseXml(), await childComponentRef2.parseXml())) {
-            childComponentsNotInRef1.push(childComponentRef2); // modified! -> add to added
-        }
-    }
-    debug({ childComponentsNotInRef1 });
-    return {
-        path,
-        status: 1 + childComponentsNotInRef2.length + childComponentsNotInRef1.length,
-        toManifest: childComponentsNotInRef1,
-        toDestructiveChanges: childComponentsNotInRef2,
-    };
-}
-function getUniqueIdentifier(component) {
-    return `${component.type.name}#${getString(component, component.type.uniqueIdElement)}`;
-}
-async function getFileStateChanges(commitHash1, commitHash2, dir) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    return git.walk({
-        fs,
-        dir,
-        trees: [git.TREE({ ref: commitHash1 }), git.TREE({ ref: commitHash2 })],
-        async map(filepath, [A, B]) {
-            if (filepath === '.' || (await A?.type()) === 'tree' || (await B?.type()) === 'tree') {
-                return;
-            }
-            const Aoid = await A?.oid();
-            const Boid = await B?.oid();
-            let type = 'EQ';
-            if (Aoid !== Boid) {
-                type = 'M';
-            }
-            if (Aoid === undefined) {
-                type = 'A';
-            }
-            if (Boid === undefined) {
-                type = 'D';
-            }
-            if (type !== 'EQ') {
-                return {
-                    path: join(dir, ensureOSPath(filepath)),
-                    status: type,
-                };
-            }
-        },
-    });
-}
-async function getStatusMatrix(dir, ref) {
-    const getStatus = (row) => {
-        if ([
-            [0, 2, 2],
-            [0, 2, 3], // added, staged, with unstaged changes
-        ].some((a) => a.every((val, index) => val === row[index]))) {
-            return 'A';
-        }
-        if ([
-            [1, 0, 0],
-            [1, 0, 1],
-            [1, 1, 0],
-            [1, 2, 0],
-            [1, 0, 3], // modified, staged, with unstaged deletion
-        ].some((a) => a.every((val, index) => val === row[index]))) {
-            return 'D';
-        }
-        if ([
-            [1, 2, 1],
-            [1, 2, 2],
-            [1, 2, 3], // modified, staged, with unstaged changes
-        ].some((a) => a.every((val, index) => val === row[index]))) {
-            return 'M';
-        }
-        return undefined;
-    };
-    const statusMatrix = await git.statusMatrix({ fs, dir, ref });
-    const warnings = statusMatrix
-        .filter((row) => [
-        [0, 2, 0],
-        [0, 0, 3],
-        [0, 2, 3],
-        [1, 2, 1],
-        [1, 0, 3],
-        [1, 1, 3],
-        [1, 2, 3],
-        [1, 1, 0],
-        [1, 2, 0],
-        [1, 0, 1], // deleted, unstaged
-    ].some((a) => a.every((val, index) => val === row.slice(1)[index])))
-        .map((row) => join(dir, ensureOSPath(row[0])));
-    const gitlines = statusMatrix
-        .filter((row) => ![
-        [0, 0, 0],
-        [1, 1, 1],
-        [0, 0, 3],
-        [0, 2, 0],
-        [1, 1, 3], // modified, staged, with unstaged original file
-    ].some((a) => a.every((val, index) => val === row.slice(1)[index])))
-        .map((row) => ({
-        path: join(dir, ensureOSPath(row[0])),
-        status: getStatus(row.slice(1)),
-    }));
-    return { warnings, lines: gitlines };
-}
-async function getGitDiff(ref1, ref2, dir) {
-    let gitlines;
-    let warnings = [];
-    const proj = await SfProject.resolve();
-    const resolveSourcePaths = proj.getUniquePackageDirectories().map((pDir) => pDir.fullPath);
-    if (ref2) {
-        gitlines = (await getFileStateChanges(ref1, ref2, dir)).filter((l) => resolveSourcePaths.some((f) => l.path.startsWith(f)));
-    }
-    else {
-        const { warnings: warn, lines } = await getStatusMatrix(dir, ref1);
-        warnings = warn.filter((l) => resolveSourcePaths.some((f) => l.startsWith(f)));
-        gitlines = lines.filter((l) => resolveSourcePaths.some((f) => l.path.startsWith(f)));
-    }
-    gitlines = gitlines.filter((line) => {
-        if (line.status === 'D') {
-            for (const sourcePath of resolveSourcePaths) {
-                const defaultFolder = join(sourcePath, 'main', 'default');
-                const filePath = line.path.replace(line.path.startsWith(defaultFolder) ? defaultFolder : sourcePath, '');
-                const target = gitlines.find((t) => t.path.endsWith(filePath) && t.status === 'A');
-                if (target) {
-                    debug(`rename: ${line.path} -> ${target.path}`);
-                    return false;
-                }
-            }
-        }
-        return true;
-    });
-    debug({ gitlines, warnings });
-    return { gitlines, warnings };
-}
-// eslint-disable-next-line complexity
-async function getGitResults(gitLines, ref1VirtualTreeContainer, ref2VirtualTreeContainer, destructiveChangesOnly, fsPaths) {
-    const results = {
-        manifest: new ComponentSet(undefined, registryAccess),
-        output: {
-            unchanged: [],
-            ignored: { ref1: [], ref2: [] },
-            counts: { added: 0, deleted: 0, modified: 0, unchanged: 0, ignored: 0, error: 0 },
-            errors: [],
-        },
-    };
-    const ref1Resolver = new MetadataResolver(registryAccess, ref1VirtualTreeContainer);
-    const ref2Resolver = new MetadataResolver(registryAccess, ref2VirtualTreeContainer);
-    const getComponentsFromPath = (resolver, path) => {
-        let result = [];
-        try {
-            result = resolver.getComponentsFromPath(path);
-        }
-        catch (error) {
-            results.output.counts.error++;
-            results.output.errors.push(error.message);
-        }
-        return result;
-    };
-    const analyzedFilesPromises = [];
-    for (const [, { status, path }] of gitLines.entries()) {
-        if (!fsPaths || fsPaths.some((fsPath) => resolve(path).startsWith(fsPath))) {
-            if (status === 'D') {
-                for (const c of getComponentsFromPath(ref1Resolver, path)) {
-                    if (c.xml === path || gitLines.find((x) => x.path === c.xml)) {
-                        results.manifest.add(c, DestructiveChangesType.POST);
-                        results.output.counts.deleted++;
-                    }
-                    else {
-                        try {
-                            if (c.xml) {
-                                // in case a binary source file of a bundle was deleted, check if the bundle ist still valid and update instead of delete
-                                ref2Resolver.getComponentsFromPath(c.xml);
-                            }
-                            if (!destructiveChangesOnly) {
-                                results.manifest.add(c);
-                                results.output.counts.added++;
-                            }
-                        }
-                        catch (error) {
-                            results.output.counts.error++;
-                            results.output.errors.push(error.message);
-                        }
-                    }
-                }
-            }
-            else if (status === 'A') {
-                if (!destructiveChangesOnly) {
-                    for (const c of getComponentsFromPath(ref2Resolver, path)) {
-                        results.manifest.add(c);
-                        results.output.counts.added++;
-                    }
-                }
-            }
-            else {
-                analyzedFilesPromises.push(analyzeFile(path, ref1VirtualTreeContainer, ref2VirtualTreeContainer));
-            }
-        }
-        else {
-            debug(`${path} not included in sourcepath`);
-        }
-    }
-    for await (const check of analyzedFilesPromises) {
-        if (check.status === 0) {
-            if (!destructiveChangesOnly) {
-                for (const c of getComponentsFromPath(ref2Resolver, check.path)) {
-                    results.manifest.add(c);
-                    results.output.counts.modified++;
-                }
-            }
-        }
-        else if (check.status === -1) {
-            results.output.unchanged.push(check.path);
-            results.output.counts.unchanged++;
-        }
-        else if (check.status === -2) {
-            results.output.counts.ignored++;
-            results.output.ignored.ref2.push(check.path);
-        }
-        else {
-            if ((check.toDestructiveChanges && check.toDestructiveChanges.length > 0) ||
-                (check.toManifest && check.toManifest.length > 0 && !destructiveChangesOnly)) {
-                results.output.counts.modified++;
-            }
-            if (check.toDestructiveChanges) {
-                for (const c of check.toDestructiveChanges) {
-                    results.manifest.add(c, DestructiveChangesType.POST);
-                }
-            }
-            if (!destructiveChangesOnly && check.toManifest) {
-                for (const c of check.toManifest) {
-                    results.manifest.add(c);
-                }
-            }
-        }
-    }
-    results.output.ignored = {
-        ref1: Array.from(ref1Resolver.forceIgnoredPaths),
-        ref2: results.output.ignored.ref2.concat(Array.from(ref2Resolver.forceIgnoredPaths)),
-    };
-    results.output.counts.ignored =
-        results.output.counts.ignored + ref1Resolver.forceIgnoredPaths.size + ref2Resolver.forceIgnoredPaths.size;
-    return results;
-}
-function fixComponentSetChilds(cs) {
-    let sourceComponents = cs.getSourceComponents();
-    // SDR library is more strict and avoids fixes like this
-    const childsTobeReplacedByParent = [
-        ...Object.keys(registry.types.workflow.children?.types ?? {}),
-        ...Object.keys(registry.types.sharingrules.children?.types ?? {}),
-        ...Object.keys(registry.types.customobjecttranslation.children?.types ?? {}),
-        ...Object.keys(registry.types.bot.children?.types ?? {}),
-    ];
-    sourceComponents = sourceComponents.map((component) => {
-        if (!component.isMarkedForDelete() && childsTobeReplacedByParent.includes(component.type.id) && component.parent) {
-            debug(`replace: ${component.type.name}:${component.fullName} -> ${component.parent.type.name}:${component.parent.fullName}`);
-            return component.parent;
-        }
-        return component;
-    });
-    return new ComponentSet(sourceComponents, registryAccess);
-}
 //# sourceMappingURL=diff.js.map