@salesforce/source-tracking 5.1.18 → 5.2.1

package/lib/shared/populateTypesAndNames.js

@@ -21,7 +21,7 @@ const functions_1 = require("./functions");
  * @input excludeUnresolvable: boolean Filter out components where you can't get the name and type (that is, it's probably not a valid source component)
  * @input resolveDeleted: constructs a virtualTree instead of the actual filesystem--useful when the files no longer exist
  */
-const populateTypesAndNames = ({ elements, projectPath, forceIgnore, excludeUnresolvable = false, resolveDeleted = false, }) => {
+const populateTypesAndNames = ({ projectPath, forceIgnore, excludeUnresolvable = false, resolveDeleted = false, registry, }) => (elements) => {
     if (elements.length === 0) {
         return [];
     }
@@ -29,7 +29,7 @@ const populateTypesAndNames = ({ elements, projectPath, forceIgnore, excludeUnre
     logger.debug(`populateTypesAndNames for ${elements.length} change elements`);
     const filenames = elements.flatMap((element) => element.filenames).filter(ts_types_1.isString);
     // component set generated from the filenames on all local changes
-    const resolver = new source_deploy_retrieve_1.MetadataResolver(undefined, resolveDeleted ? source_deploy_retrieve_1.VirtualTreeContainer.fromFilePaths(filenames) : undefined, !!forceIgnore);
+    const resolver = new source_deploy_retrieve_1.MetadataResolver(registry, resolveDeleted ? source_deploy_retrieve_1.VirtualTreeContainer.fromFilePaths(filenames) : undefined, !!forceIgnore);
     const sourceComponents = filenames
         .flatMap((filename) => {
         try {
@@ -42,37 +42,28 @@ const populateTypesAndNames = ({ elements, projectPath, forceIgnore, excludeUnre
     })
         .filter(guards_1.sourceComponentGuard);
     logger.debug(` matching SourceComponents have ${sourceComponents.length} items from local`);
-    // make it simpler to find things later
-    const elementMap = new Map();
-    elements.map((element) => {
-        element.filenames?.map((filename) => {
-            elementMap.set((0, functions_1.ensureRelative)(filename, projectPath), element);
-        });
-    });
+    const elementMap = new Map(elements.flatMap((e) => (e.filenames ?? []).map((f) => [(0, functions_1.ensureRelative)(projectPath)(f), e])));
     // iterates the local components and sets their filenames
-    sourceComponents.map((matchingComponent) => {
-        if (matchingComponent?.fullName && matchingComponent?.type.name) {
-            const filenamesFromMatchingComponent = [matchingComponent.xml, ...matchingComponent.walkContent()];
-            const ignored = filenamesFromMatchingComponent
-                .filter(ts_types_1.isString)
-                .filter((f) => !(0, functions_1.isLwcLocalOnlyTest)(f))
-                .some((f) => forceIgnore?.denies(f));
-            filenamesFromMatchingComponent.map((filename) => {
-                if (filename && elementMap.has(filename)) {
-                    // add the type/name from the componentSet onto the element
-                    elementMap.set(filename, {
-                        origin: 'remote',
-                        ...elementMap.get(filename),
-                        type: matchingComponent.type.name,
-                        name: matchingComponent.fullName,
-                        ignored,
-                    });
-                }
-            });
-        }
+    sourceComponents.filter(functions_1.sourceComponentHasFullNameAndType).map((matchingComponent) => {
+        const filenamesFromMatchingComponent = (0, functions_1.getAllFiles)(matchingComponent);
+        const ignored = filenamesFromMatchingComponent
+            .filter(functions_1.excludeLwcLocalOnlyTest)
+            .some((0, functions_1.forceIgnoreDenies)(forceIgnore));
+        filenamesFromMatchingComponent.map((filename) => {
+            if (filename && elementMap.has(filename)) {
+                // add the type/name from the componentSet onto the element
+                elementMap.set(filename, {
+                    origin: 'remote',
+                    ...elementMap.get(filename),
+                    type: matchingComponent.type.name,
+                    name: matchingComponent.fullName,
+                    ignored,
+                });
+            }
+        });
     });
     return excludeUnresolvable
-        ? Array.from(new Set(elementMap.values())).filter((changeResult) => changeResult.name && changeResult.type)
+        ? Array.from(new Set(elementMap.values())).filter(guards_1.isChangeResultWithNameAndType)
         : Array.from(new Set(elementMap.values()));
 };
 exports.populateTypesAndNames = populateTypesAndNames;

package/lib/shared/remoteChangeIgnoring.d.ts

@@ -1,5 +1,5 @@
-import { ForceIgnore, MetadataComponent, MetadataMember, RegistryAccess } from '@salesforce/source-deploy-retrieve';
+import { ForceIgnore, MetadataMember } from '@salesforce/source-deploy-retrieve';
 import { ChangeResult } from './types';
-export declare const changeResultToMetadataComponent: (cr: ChangeResult, registry?: RegistryAccess) => MetadataComponent;
+import { ChangeResultWithNameAndType } from './types';
 export declare const removeIgnored: (changeResults: ChangeResult[], forceIgnore: ForceIgnore, defaultPkgDir: string) => MetadataMember[];
-export declare const remoteChangeToMetadataMember: (cr: ChangeResult) => MetadataMember;
+export declare const ensureNameAndType: (cr: ChangeResult) => ChangeResultWithNameAndType;

package/lib/shared/remoteChangeIgnoring.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.remoteChangeToMetadataMember = exports.removeIgnored = exports.changeResultToMetadataComponent = void 0;
+exports.ensureNameAndType = exports.removeIgnored = void 0;
 /*
  * Copyright (c) 2023, salesforce.com, inc.
  * All rights reserved.
@@ -10,32 +10,26 @@ exports.remoteChangeToMetadataMember = exports.removeIgnored = exports.changeRes
 const source_deploy_retrieve_1 = require("@salesforce/source-deploy-retrieve");
 const core_1 = require("@salesforce/core");
 const filePathGenerator_1 = require("@salesforce/source-deploy-retrieve/lib/src/utils/filePathGenerator");
-const changeResultToMetadataComponent = (cr, registry = new source_deploy_retrieve_1.RegistryAccess()) => {
-    if (!cr.name || !cr.type) {
-        throw new core_1.SfError(`Change Result is missing name or type: ${JSON.stringify(cr)}`);
-    }
-    return {
-        fullName: cr.name,
-        type: registry.getTypeByName(cr.type),
-    };
-};
-exports.changeResultToMetadataComponent = changeResultToMetadataComponent;
+const guards_1 = require("./guards");
+const functions_1 = require("./functions");
 const removeIgnored = (changeResults, forceIgnore, defaultPkgDir) => {
     const registry = new source_deploy_retrieve_1.RegistryAccess();
     return changeResults
-        .map((cr) => (0, exports.changeResultToMetadataComponent)(cr, registry))
-        .filter((mc) => !(0, filePathGenerator_1.filePathsFromMetadataComponent)(mc, defaultPkgDir).some((f) => forceIgnore.denies(f)))
-        .map((mc) => ({ type: mc.type.name, fullName: mc.fullName }));
+        .map(exports.ensureNameAndType)
+        .map((0, functions_1.changeResultToMetadataComponent)(registry))
+        .filter((mc) => !(0, filePathGenerator_1.filePathsFromMetadataComponent)(mc, defaultPkgDir).some((0, functions_1.forceIgnoreDenies)(forceIgnore)))
+        .map(metadataComponentToMetadataMember);
 };
 exports.removeIgnored = removeIgnored;
-const remoteChangeToMetadataMember = (cr) => {
-    if (!cr.name || !cr.type) {
-        throw new core_1.SfError(`Change Result is missing name or type: ${JSON.stringify(cr)}`);
+const metadataComponentToMetadataMember = (mc) => ({
+    type: mc.type.name,
+    fullName: mc.fullName,
+});
+const ensureNameAndType = (cr) => {
+    if ((0, guards_1.isChangeResultWithNameAndType)(cr)) {
+        return cr;
     }
-    return {
-        fullName: cr.name,
-        type: cr.type,
-    };
+    throw new core_1.SfError(`Change Result is missing name or type: ${JSON.stringify(cr)}`);
 };
-exports.remoteChangeToMetadataMember = remoteChangeToMetadataMember;
+exports.ensureNameAndType = ensureNameAndType;
 //# sourceMappingURL=remoteChangeIgnoring.js.map

package/lib/shared/remoteSourceTrackingService.d.ts

@@ -1,4 +1,4 @@
-import { Org, Connection } from '@salesforce/core';
+import { Logger, Org, Connection } from '@salesforce/core';
 import { Duration } from '@salesforce/kit';
 import { ChangeResult, RemoteChangeElement, MemberRevision, SourceMember, RemoteSyncInput } from './types';
 /** represents the contents of the config file stored in 'maxRevision.json' */
@@ -128,6 +128,6 @@ export declare class RemoteSourceTrackingService {
  * Useful for correcing bundle types where the files show change results with types but aren't resolvable
  */
 export declare const remoteChangeElementToChangeResult: (rce: RemoteChangeElement) => ChangeResult;
-export declare const calculateTimeout: (memberCount: number) => Duration;
+export declare const calculateTimeout: (logger: Logger) => (memberCount: number) => Duration;
 /** exported only for spy/mock  */
 export declare const querySourceMembersTo: (conn: Connection, toRevision: number) => Promise<SourceMember[]>;

package/lib/shared/remoteSourceTrackingService.js

@@ -123,7 +123,7 @@ class RemoteSourceTrackingService {
             if (!revision) {
                 this.logger.warn(`found no matching revision for ${metadataKey}`);
             }
-            else if (revision.lastRetrievedFromServer !== revision.serverRevisionCounter) {
+            else if (doesNotMatchServer(revision)) {
                 if (!quiet) {
                     this.logger.debug(`Syncing ${metadataKey} revision from ${revision.lastRetrievedFromServer} to ${revision.serverRevisionCounter}`);
                 }
@@ -171,8 +171,8 @@ class RemoteSourceTrackingService {
         // Look for any changed that haven't been synced.  I.e, the lastRetrievedFromServer
         // does not match the serverRevisionCounter.
         const returnElements = Array.from(this.sourceMembers.entries())
-            .filter(([, member]) => member.serverRevisionCounter !== member.lastRetrievedFromServer)
-            .map(([key, member]) => convertRevisionToChange(key, member));
+            .filter(revisionDoesNotMatch)
+            .map(revisionToRemoteChangeElement);
         this.logger.debug(returnElements.length
             ? `Found ${returnElements.length} elements not synced with org`
             : 'Remote source tracking is up to date');
@@ -198,7 +198,7 @@ class RemoteSourceTrackingService {
         const originalOutstandingSize = outstandingSourceMembers.size;
         // this will be the absolute timeout from the start of the poll.  We can also exit early if it doesn't look like more results are coming in
         let highestRevisionSoFar = this.serverMaxRevisionCounter;
-        const pollingTimeout = (0, exports.calculateTimeout)(outstandingSourceMembers.size);
+        const pollingTimeout = (0, exports.calculateTimeout)(this.logger)(outstandingSourceMembers.size);
         let pollAttempts = 0;
         let consecutiveEmptyResults = 0;
         let someResultsReturned = false;
@@ -425,7 +425,7 @@ const remoteChangeElementToChangeResult = (rce) => ({
     origin: 'remote', // we know they're remote
 });
 exports.remoteChangeElementToChangeResult = remoteChangeElementToChangeResult;
-const convertRevisionToChange = (memberKey, memberRevision) => ({
+const revisionToRemoteChangeElement = ([memberKey, memberRevision]) => ({
     type: memberRevision.memberType,
     name: memberKey.replace(`${memberRevision.memberType}__`, ''),
     deleted: memberRevision.isNameObsolete,
@@ -462,8 +462,7 @@ const readFileContents = async (filePath) => {
         return {};
     }
 };
-const calculateTimeout = (memberCount) => {
-    const logger = core_1.Logger.childFromRoot('remoteSourceTrackingService:calculateTimeout');
+const calculateTimeout = (logger) => (memberCount) => {
     const overriddenTimeout = kit_1.env.getNumber('SFDX_SOURCE_MEMBER_POLLING_TIMEOUT', 0);
     if (overriddenTimeout > 0) {
         logger.debug(`Overriding SourceMember polling timeout to ${overriddenTimeout}`);
@@ -485,10 +484,10 @@ const querySourceMembersTo = async (conn, toRevision) => {
 exports.querySourceMembersTo = querySourceMembersTo;
 const queryFn = async (conn, query) => {
     try {
-        return (await conn.tooling.query(query, { autoFetch: true, maxFetch: 50000 })).records;
+        return (await conn.tooling.query(query, { autoFetch: true, maxFetch: 50_000 })).records;
     }
     catch (error) {
-        throw core_1.SfError.wrap(error);
+        throw error instanceof Error ? core_1.SfError.wrap(error) : error;
     }
 };
 /** organize by type and format for warning output */
@@ -502,4 +501,6 @@ const formatSourceMemberWarnings = (outstandingSourceMembers) => {
         .map(([type, names]) => `  - ${type}: ${names.join(', ')}`)
         .join(node_os_1.EOL);
 };
+const revisionDoesNotMatch = ([, member]) => doesNotMatchServer(member);
+const doesNotMatchServer = (member) => member.serverRevisionCounter !== member.lastRetrievedFromServer;
 //# sourceMappingURL=remoteSourceTrackingService.js.map

package/lib/shared/types.d.ts

@@ -61,3 +61,4 @@ export type SourceMemberPollingEvent = {
     attempts: number;
     consecutiveEmptyResults: number;
 };
+export type ChangeResultWithNameAndType = ChangeResult & Required<Pick<ChangeResult, 'name' | 'type'>>;

package/lib/sourceTracking.d.ts

@@ -1,6 +1,6 @@
 import { Org, SfProject } from '@salesforce/core';
 import { AsyncCreatable } from '@salesforce/kit';
-import { ComponentSet, SourceComponent, FileResponse, DeployResult, RetrieveResult } from '@salesforce/source-deploy-retrieve';
+import { ComponentSet, SourceComponent, FileResponse, DeployResult, RetrieveResult, RegistryAccess } from '@salesforce/source-deploy-retrieve';
 import { RemoteSyncInput, StatusOutputRow, ChangeOptions, ChangeResult, LocalUpdateOptions } from './shared/types';
 export interface SourceTrackingOptions {
     org: Org;
@@ -30,9 +30,10 @@ type RemoteChangesResults = {
  *
  */
 export declare class SourceTracking extends AsyncCreatable {
+    readonly registry: RegistryAccess;
+    readonly projectPath: string;
     private org;
     private project;
-    private projectPath;
     private packagesDirs;
     private logger;
     private localRepo;
@@ -189,8 +190,6 @@ export declare class SourceTracking extends AsyncCreatable {
     setIgnoreConflicts(value: boolean): void;
     private maybeSubscribeLifecycleEvents;
     private getLocalStatusRows;
-    private getLocalChangesAsFilenames;
-    private localChangesToOutputRow;
     private remoteChangesToOutputRows;
 }
 export {};

package/lib/sourceTracking.js

@@ -22,10 +22,12 @@ const conflicts_1 = require("./shared/conflicts");
 const guards_1 = require("./shared/guards");
 const remoteChangeIgnoring_1 = require("./shared/remoteChangeIgnoring");
 const functions_1 = require("./shared/functions");
+const functions_2 = require("./shared/functions");
 const metadataKeys_1 = require("./shared/metadataKeys");
 const populateFilePaths_1 = require("./shared/populateFilePaths");
 const populateTypesAndNames_1 = require("./shared/populateTypesAndNames");
 const localComponentSetArray_1 = require("./shared/localComponentSetArray");
+const functions_3 = require("./shared/functions");
 /**
  * Manages source tracking files (remote and local)
  *
@@ -44,6 +46,7 @@ class SourceTracking extends kit_1.AsyncCreatable {
         this.ignoreConflicts = options.ignoreConflicts ?? false;
         this.ignoreLocalCache = options.ignoreLocalCache ?? false;
         this.subscribeSDREvents = options.subscribeSDREvents ?? false;
+        this.registry = new source_deploy_retrieve_1.RegistryAccess(undefined, this.projectPath);
     }
     async init() {
         await this.maybeSubscribeLifecycleEvents();
@@ -72,7 +75,7 @@ class SourceTracking extends kit_1.AsyncCreatable {
             deletes,
         }, byPackageDir ?? Boolean(projectConfig.pushPackageDirectoriesSequentially)); // if the users specified true or false for the param, that overrides the project config
         this.logger.debug(`will build array of ${groupings.length} componentSet(s)`);
-        return (0, localComponentSetArray_1.getComponentSets)(groupings, sourceApiVersion);
+        return (0, localComponentSetArray_1.getComponentSets)({ groupings, sourceApiVersion, registry: this.registry });
     }
     /** reads tracking files for remote changes.  It DOES NOT consider the effects of .forceignore unless told to */
     async remoteNonDeletesAsComponentSet({ applyIgnore = false, } = {}) {
@@ -94,13 +97,11 @@ class SourceTracking extends kit_1.AsyncCreatable {
             }),
             this.project.resolveProjectConfig(),
         ]);
-        const componentSet = new source_deploy_retrieve_1.ComponentSet(applyIgnore
-            ? sourceBackedComponents.filter((sc) => ![sc.content, sc.xml].some((f) => f && this.forceIgnore.denies(f)))
-            : sourceBackedComponents);
+        const componentSet = new source_deploy_retrieve_1.ComponentSet(applyIgnore ? sourceBackedComponents.filter(noFileIsIgnored(this.forceIgnore)) : sourceBackedComponents, this.registry);
         // there may be remote adds not in the SBC.  So we add those manually
         (applyIgnore
             ? (0, remoteChangeIgnoring_1.removeIgnored)(changeResults, this.forceIgnore, this.project.getDefaultPackage().fullPath)
-            : changeResults.map(remoteChangeIgnoring_1.remoteChangeToMetadataMember)).forEach((mm) => {
+            : changeResults.map(functions_1.remoteChangeToMetadataMember)).map((mm) => {
             componentSet.add(mm);
         });
         if (projectConfig.sourceApiVersion) {
@@ -131,10 +132,10 @@ class SourceTracking extends kit_1.AsyncCreatable {
         }
         if (local && remote) {
             // keys like ApexClass__MyClass.cls
-            const conflictFiles = (await this.getConflicts()).flatMap((conflict) => conflict.filenames).filter(ts_types_1.isString);
+            const conflictFiles = new Set((await this.getConflicts()).flatMap((conflict) => conflict.filenames).filter(ts_types_1.isString));
             results = results.map((row) => ({
                 ...row,
-                conflict: !!row.filePath && conflictFiles.includes(row.filePath),
+                conflict: !!row.filePath && conflictFiles.has(row.filePath),
             }));
         }
         return results;
@@ -142,7 +143,7 @@ class SourceTracking extends kit_1.AsyncCreatable {
     async getChanges(options) {
         if (options?.origin === 'local') {
             await this.ensureLocalTracking();
-            const filenames = await this.getLocalChangesAsFilenames(options.state);
+            const filenames = await getLocalChangesAsFilenames(this.localRepo)(options.state);
             if (options.format === 'string') {
                 return filenames;
             }
@@ -153,9 +154,7 @@ class SourceTracking extends kit_1.AsyncCreatable {
                 }));
             }
             if (options.format === 'SourceComponent') {
-                const resolver = options.state === 'delete'
-                    ? new source_deploy_retrieve_1.MetadataResolver(undefined, source_deploy_retrieve_1.VirtualTreeContainer.fromFilePaths(filenames))
-                    : new source_deploy_retrieve_1.MetadataResolver();
+                const resolver = new source_deploy_retrieve_1.MetadataResolver(this.registry, options.state === 'delete' ? source_deploy_retrieve_1.VirtualTreeContainer.fromFilePaths(filenames) : undefined);
                 return filenames
                     .flatMap((filename) => {
                     try {
@@ -178,25 +177,27 @@ class SourceTracking extends kit_1.AsyncCreatable {
                 // skip any remote types not in the registry.  Will emit warnings
                 .filter((rce) => (0, metadataKeys_1.registrySupportsType)(rce.type));
             if (options.format === 'ChangeResult') {
-                return filteredChanges.map((change) => (0, remoteSourceTrackingService_1.remoteChangeElementToChangeResult)(change));
+                return filteredChanges.map(remoteSourceTrackingService_1.remoteChangeElementToChangeResult);
             }
             if (options.format === 'ChangeResultWithPaths') {
-                return (0, populateFilePaths_1.populateFilePaths)(filteredChanges.map((change) => (0, remoteSourceTrackingService_1.remoteChangeElementToChangeResult)(change)), this.project.getPackageDirectories().map((pkgDir) => pkgDir.path));
+                return (0, populateFilePaths_1.populateFilePaths)({
+                    elements: filteredChanges.map(remoteSourceTrackingService_1.remoteChangeElementToChangeResult),
+                    packageDirPaths: this.project.getPackageDirectories().map((pkgDir) => pkgDir.path),
+                    registry: this.registry,
+                });
             }
             // turn it into a componentSet to resolve filenames
             const remoteChangesAsComponentSet = new source_deploy_retrieve_1.ComponentSet(filteredChanges.map((element) => ({
                 type: element?.type,
                 fullName: element?.name,
-            })));
+            })), this.registry);
             const matchingLocalSourceComponentsSet = source_deploy_retrieve_1.ComponentSet.fromSource({
                 fsPaths: this.packagesDirs.map((dir) => (0, node_path_1.resolve)(dir.fullPath)),
                 include: remoteChangesAsComponentSet,
+                registry: this.registry,
             });
             if (options.format === 'string') {
-                return matchingLocalSourceComponentsSet
-                    .getSourceComponents()
-                    .toArray()
-                    .flatMap((component) => [component.xml, ...component.walkContent()].filter((filename) => filename));
+                return matchingLocalSourceComponentsSet.getSourceComponents().toArray().flatMap(functions_2.getAllFiles);
             }
             else if (options.format === 'SourceComponent') {
                 return matchingLocalSourceComponentsSet.getSourceComponents().toArray();
@@ -224,12 +225,9 @@ class SourceTracking extends kit_1.AsyncCreatable {
         if (changesToDelete.length === 0) {
             return [];
         }
-        const sourceComponentByFileName = new Map();
-        changesToDelete.flatMap((component) => [component.xml, ...component.walkContent()]
-            .filter((filename) => filename)
-            .map((filename) => sourceComponentByFileName.set(filename, component)));
+        const sourceComponentByFileName = new Map(changesToDelete.flatMap((component) => (0, functions_2.getAllFiles)(component).map((filename) => [filename, component])));
         // calculate what to return before we delete any files and .walkContent is no longer valid
-        const changedToBeDeleted = changesToDelete.flatMap((component) => [...component.walkContent(), component.xml].map((file) => ({
+        const changedToBeDeleted = changesToDelete.flatMap((component) => (0, functions_2.getAllFiles)(component).map((file) => ({
             state: source_deploy_retrieve_1.ComponentStatus.Deleted,
             filePath: file,
             type: component.type.name,
@@ -237,14 +235,9 @@ class SourceTracking extends kit_1.AsyncCreatable {
         })));
         const filenames = Array.from(sourceComponentByFileName.keys());
         // delete the files
-        await Promise.all(filenames.map(async (filename) => {
-            if (sourceComponentByFileName.get(filename)?.type.id === 'customlabel') {
-                await (0, functions_1.deleteCustomLabels)(filename, changesToDelete.filter((c) => c.type.id === 'customlabel'));
-            }
-            else {
-                return fs.promises.unlink(filename);
-            }
-        }));
+        await Promise.all(filenames.map((filename) => sourceComponentByFileName.get(filename)?.type.id === 'customlabel'
+            ? (0, functions_2.deleteCustomLabels)(filename, changesToDelete.filter(functions_3.sourceComponentIsCustomLabel))
+            : fs.promises.unlink(filename)));
         // update the tracking files.  We're simulating SDR-style fileResponse
         await Promise.all([
             this.updateLocalTracking({ deletedFiles: filenames }),
@@ -267,10 +260,11 @@ class SourceTracking extends kit_1.AsyncCreatable {
         const marker = core_2.Performance.mark('@salesforce/source-tracking', 'SourceTracking.updateLocalTracking');
         marker?.addDetails({ nonDeletes: options.files?.length ?? 0, deletes: options.deletedFiles?.length ?? 0 });
         await this.ensureLocalTracking();
+        this.logger.trace('files', options.files);
         // relative paths make smaller trees AND isogit wants them relative
         const relativeOptions = {
-            files: (options.files ?? []).map((file) => (0, functions_1.ensureRelative)(file, this.projectPath)),
-            deletedFiles: (options.deletedFiles ?? []).map((file) => (0, functions_1.ensureRelative)(file, this.projectPath)),
+            files: (options.files ?? []).map((0, functions_2.ensureRelative)(this.projectPath)),
+            deletedFiles: (options.deletedFiles ?? []).map((0, functions_2.ensureRelative)(this.projectPath)),
         };
         // plot twist: if you delete a member of a bundle (ex: lwc/foo/foo.css) and push, it'll not be in the fileResponses (deployedFiles) or deletedFiles
         // what got deleted?  Any local changes NOT in the fileResponses but part of a successfully deployed bundle
@@ -278,16 +272,17 @@ class SourceTracking extends kit_1.AsyncCreatable {
             // resolve from highest possible level.  TODO: can we use [.]
             fsPaths: relativeOptions.files.length ? [relativeOptions.files[0].split(node_path_1.sep)[0]] : [],
             tree: source_deploy_retrieve_1.VirtualTreeContainer.fromFilePaths(relativeOptions.files),
+            registry: this.registry,
         });
         // these are top-level bundle paths like lwc/foo
         const bundlesWithDeletedFiles = (await this.getChanges({ origin: 'local', state: 'delete', format: 'SourceComponent' }))
-            .filter(functions_1.supportsPartialDelete)
+            .filter(functions_2.supportsPartialDelete)
             .filter((cmp) => deployedFilesAsVirtualComponentSet.has({ type: cmp.type, fullName: cmp.fullName }))
             .map((cmp) => cmp.content)
             .filter(ts_types_1.isString);
         await this.localRepo.commitChanges({
             deployedFiles: relativeOptions.files,
-            deletedFiles: relativeOptions.deletedFiles.concat((await this.localRepo.getDeleteFilenames()).filter((deployedFile) => bundlesWithDeletedFiles.some((bundlePath) => (0, functions_1.pathIsInFolder)(deployedFile, bundlePath)) &&
+            deletedFiles: relativeOptions.deletedFiles.concat((await this.localRepo.getDeleteFilenames()).filter((deployedFile) => bundlesWithDeletedFiles.some((0, functions_2.folderContainsPath)(deployedFile)) &&
                 !relativeOptions.files.includes(deployedFile))),
         });
         marker?.stop();
@@ -421,6 +416,7 @@ class SourceTracking extends kit_1.AsyncCreatable {
             remoteChanges,
             projectPath: this.projectPath,
             forceIgnore: this.forceIgnore,
+            registry: this.registry,
         });
         marker?.stop();
         return result;
@@ -431,23 +427,17 @@ class SourceTracking extends kit_1.AsyncCreatable {
      * @param result FileResponse[]
      */
     async updateTrackingFromDeploy(deployResult) {
-        const successes = deployResult
-            .getFileResponses()
-            .filter((fileResponse) => fileResponse.state !== source_deploy_retrieve_1.ComponentStatus.Failed && fileResponse.filePath);
+        const successes = deployResult.getFileResponses().filter(guards_1.isSdrSuccess).filter(guards_1.FileResponseHasPath);
         if (!successes.length) {
             return;
         }
         await Promise.all([
             this.updateLocalTracking({
                 // assertions allowed because filtered above
-                files: successes
-                    .filter((fileResponse) => fileResponse.state !== source_deploy_retrieve_1.ComponentStatus.Deleted)
-                    .map((fileResponse) => fileResponse.filePath),
-                deletedFiles: successes
-                    .filter((fileResponse) => fileResponse.state === source_deploy_retrieve_1.ComponentStatus.Deleted)
-                    .map((fileResponse) => fileResponse.filePath),
+                files: successes.filter(guards_1.FileResponseIsNotDeleted).map(filePathFromFileResponse),
+                deletedFiles: successes.filter(guards_1.FileResponseIsDeleted).map(filePathFromFileResponse),
             }),
-            this.updateRemoteTracking(successes.map(({ state, fullName, type, filePath }) => ({ state, fullName, type, filePath }))),
+            this.updateRemoteTracking(successes.map(functions_1.FileResponseSuccessToRemoteSyncInput)),
         ]);
     }
     /**
@@ -456,25 +446,17 @@ class SourceTracking extends kit_1.AsyncCreatable {
      * @param result FileResponse[]
      */
     async updateTrackingFromRetrieve(retrieveResult) {
-        const successes = retrieveResult
-            .getFileResponses()
-            .filter((fileResponse) => fileResponse.state !== source_deploy_retrieve_1.ComponentStatus.Failed);
+        const successes = retrieveResult.getFileResponses().filter(guards_1.isSdrSuccess);
         if (!successes.length) {
             return;
         }
         await Promise.all([
             this.updateLocalTracking({
                 // assertion allowed because it's filtering out undefined
-                files: successes
-                    .filter((fileResponse) => fileResponse.state !== source_deploy_retrieve_1.ComponentStatus.Deleted)
-                    .map((fileResponse) => fileResponse.filePath)
-                    .filter(Boolean),
-                deletedFiles: successes
-                    .filter((fileResponse) => fileResponse.state === source_deploy_retrieve_1.ComponentStatus.Deleted)
-                    .map((fileResponse) => fileResponse.filePath)
-                    .filter(Boolean),
+                files: successes.filter(guards_1.FileResponseIsNotDeleted).filter(guards_1.FileResponseHasPath).map(filePathFromFileResponse),
+                deletedFiles: successes.filter(guards_1.FileResponseIsDeleted).filter(guards_1.FileResponseHasPath).map(filePathFromFileResponse),
             }),
-            this.updateRemoteTracking(successes.map(({ state, fullName, type, filePath }) => ({ state, fullName, type, filePath })), true // retrieves don't need to poll for SourceMembers
+            this.updateRemoteTracking(successes.map(functions_1.FileResponseSuccessToRemoteSyncInput), true // retrieves don't need to poll for SourceMembers
             ),
         ]);
     }
@@ -526,55 +508,15 @@ class SourceTracking extends kit_1.AsyncCreatable {
     }
     async getLocalStatusRows() {
         await this.ensureLocalTracking();
-        let results = [];
-        const localDeletes = (0, populateTypesAndNames_1.populateTypesAndNames)({
-            elements: await this.getChanges({ origin: 'local', state: 'delete', format: 'ChangeResult' }),
-            excludeUnresolvable: true,
-            resolveDeleted: true,
-            projectPath: this.projectPath,
-        });
-        const localAdds = (0, populateTypesAndNames_1.populateTypesAndNames)({
-            elements: await this.getChanges({ origin: 'local', state: 'add', format: 'ChangeResult' }),
-            excludeUnresolvable: true,
-            projectPath: this.projectPath,
-        });
-        const localModifies = (0, populateTypesAndNames_1.populateTypesAndNames)({
-            elements: await this.getChanges({ origin: 'local', state: 'modify', format: 'ChangeResult' }),
-            excludeUnresolvable: true,
-            projectPath: this.projectPath,
-        });
-        results = results.concat(localAdds.flatMap((item) => this.localChangesToOutputRow(item, 'add')), localModifies.flatMap((item) => this.localChangesToOutputRow(item, 'modify')), localDeletes.flatMap((item) => this.localChangesToOutputRow(item, 'delete')));
-        return results;
-    }
-    async getLocalChangesAsFilenames(state) {
-        if (state === 'modify') {
-            return this.localRepo.getModifyFilenames();
-        }
-        if (state === 'nondelete') {
-            return this.localRepo.getNonDeleteFilenames();
-        }
-        if (state === 'delete') {
-            return this.localRepo.getDeleteFilenames();
-        }
-        if (state === 'add') {
-            return this.localRepo.getAddFilenames();
-        }
-        throw new Error(`unable to get local changes for state ${state}`);
-    }
-    localChangesToOutputRow(input, localType) {
-        this.logger.debug('converting ChangeResult to a row', input);
-        this.forceIgnore ??= source_deploy_retrieve_1.ForceIgnore.findAndCreate(this.project.getDefaultPackage().path);
-        if (input.filenames) {
-            return input.filenames.map((filename) => ({
-                type: input.type ?? '',
-                state: localType,
-                fullName: input.name ?? '',
-                filePath: filename,
-                origin: 'local',
-                ignored: this.forceIgnore.denies(filename),
-            }));
-        }
-        throw new Error('no filenames found for local ChangeResult');
+        this.forceIgnore ??= source_deploy_retrieve_1.ForceIgnore.findAndCreate(this.project.getDefaultPackage().path); // ensure forceignore is initialized
+        const [adds, modifies, deletes] = await Promise.all(['add', 'modify', 'delete'].map((state) => this.getChanges({ origin: 'local', state, format: 'ChangeResult' })));
+        const base = { projectPath: this.projectPath, registry: this.registry, excludeUnresolvable: true };
+        const toOutput = localChangesToOutputRow(this.logger)(this.forceIgnore);
+        return [
+            ...(0, populateTypesAndNames_1.populateTypesAndNames)(base)(adds).flatMap(toOutput('add')),
+            ...(0, populateTypesAndNames_1.populateTypesAndNames)(base)(modifies).flatMap(toOutput('modify')),
+            ...(0, populateTypesAndNames_1.populateTypesAndNames)({ ...base, resolveDeleted: true })(deletes).flatMap(toOutput('delete')),
+        ];
     }
     // reserve the right to do something more sophisticated in the future
     // via async for figuring out hypothetical filenames (ex: getting default packageDir)
@@ -598,14 +540,12 @@ class SourceTracking extends kit_1.AsyncCreatable {
         }
         // when the file doesn't exist locally, there are no filePaths
         // SDR can generate the hypothetical place it *would* go and check that
-        if (input.name && input.type) {
+        if ((0, guards_1.isChangeResultWithNameAndType)(input)) {
+            const ignored = (0, filePathGenerator_1.filePathsFromMetadataComponent)((0, functions_1.changeResultToMetadataComponent)(registry)(input)).some((0, functions_2.forceIgnoreDenies)(this.forceIgnore));
             return [
                 {
                     ...baseObject,
-                    ignored: (0, filePathGenerator_1.filePathsFromMetadataComponent)({
-                        fullName: input.name,
-                        type: registry.getTypeByName(input.type),
-                    }).some((hypotheticalFilePath) => this.forceIgnore.denies(hypotheticalFilePath)),
+                    ignored,
                 },
             ];
         }
@@ -628,4 +568,32 @@ const stateFromChangeResult = (input) => {
     }
     return 'add';
 };
+const getLocalChangesAsFilenames = (localRepo) => async (state) => {
+    switch (state) {
+        case 'modify':
+            return localRepo.getModifyFilenames();
+        case 'nondelete':
+            return localRepo.getNonDeleteFilenames();
+        case 'delete':
+            return localRepo.getDeleteFilenames();
+        case 'add':
+            return localRepo.getAddFilenames();
+    }
+};
+const filePathFromFileResponse = (input) => input.filePath;
+const noFileIsIgnored = (forceIgnore) => (cmp) => !(0, functions_2.getAllFiles)(cmp).some((0, functions_2.forceIgnoreDenies)(forceIgnore));
+const localChangesToOutputRow = (logger) => (forceIgnore) => (localType) => (input) => {
+    logger.debug('converting ChangeResult to a row', input);
+    if (input.filenames) {
+        return input.filenames.map((filename) => ({
+            type: input.type ?? '',
+            state: localType,
+            fullName: input.name ?? '',
+            filePath: filename,
+            origin: 'local',
+            ignored: forceIgnore.denies(filename),
+        }));
+    }
+    throw new Error('no filenames found for local ChangeResult');
+};
 //# sourceMappingURL=sourceTracking.js.map