@salesforce/source-tracking 5.1.18 → 5.2.1

package/lib/index.d.ts

@@ -1,3 +1,3 @@
-export * from './sourceTracking';
+export { SourceTracking, SourceTrackingOptions } from './sourceTracking';
 export { RemoteSyncInput, ChangeOptionType, ChangeOptions, LocalUpdateOptions, ChangeResult, StatusOutputRow, ConflictResponse, SourceConflictError, SourceMemberPollingEvent, } from './shared/types';
 export { getKeyFromObject, deleteCustomLabels } from './shared/functions';

package/lib/index.js

@@ -5,23 +5,10 @@
  * 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
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deleteCustomLabels = exports.getKeyFromObject = exports.SourceConflictError = void 0;
-__exportStar(require("./sourceTracking"), exports);
+exports.deleteCustomLabels = exports.getKeyFromObject = exports.SourceConflictError = exports.SourceTracking = void 0;
+var sourceTracking_1 = require("./sourceTracking");
+Object.defineProperty(exports, "SourceTracking", { enumerable: true, get: function () { return sourceTracking_1.SourceTracking; } });
 var types_1 = require("./shared/types");
 Object.defineProperty(exports, "SourceConflictError", { enumerable: true, get: function () { return types_1.SourceConflictError; } });
 var functions_1 = require("./shared/functions");

package/lib/shared/conflicts.d.ts

@@ -1,4 +1,4 @@
-import { ComponentSet, ForceIgnore } from '@salesforce/source-deploy-retrieve';
+import { ComponentSet, ForceIgnore, RegistryAccess } from '@salesforce/source-deploy-retrieve';
 import { ConflictResponse, ChangeResult } from './types';
 export declare const throwIfConflicts: (conflicts: ConflictResponse[]) => void;
 /**
@@ -8,9 +8,10 @@ export declare const throwIfConflicts: (conflicts: ConflictResponse[]) => void;
  * @returns ConflictResponse[] de-duped and formatted for json or table display
  */
 export declare const findConflictsInComponentSet: (cs: ComponentSet, conflicts: ChangeResult[]) => ConflictResponse[];
-export declare const getDedupedConflictsFromChanges: ({ localChanges, remoteChanges, projectPath, forceIgnore, }: {
+export declare const getDedupedConflictsFromChanges: ({ localChanges, remoteChanges, projectPath, forceIgnore, registry, }: {
     localChanges: ChangeResult[];
     remoteChanges: ChangeResult[];
     projectPath: string;
     forceIgnore: ForceIgnore;
+    registry: RegistryAccess;
 }) => ChangeResult[];

package/lib/shared/conflicts.js

@@ -11,6 +11,7 @@ const node_path_1 = require("node:path");
 const types_1 = require("./types");
 const functions_1 = require("./functions");
 const populateTypesAndNames_1 = require("./populateTypesAndNames");
+const guards_1 = require("./guards");
 const throwIfConflicts = (conflicts) => {
     if (conflicts.length > 0) {
         throw new types_1.SourceConflictError(`${conflicts.length} conflicts detected`, conflicts);
@@ -27,13 +28,12 @@ const findConflictsInComponentSet = (cs, conflicts) => {
     // map do dedupe by name-type-filename
     const conflictMap = new Map();
     conflicts
-        .filter((cr) => cr.name && cr.type && cs.has({ fullName: cr.name, type: cr.type }))
+        .filter(guards_1.isChangeResultWithNameAndType)
+        .filter((cr) => cs.has({ fullName: cr.name, type: cr.type }))
         .forEach((cr) => {
         cr.filenames?.forEach((f) => {
             conflictMap.set(`${cr.name}#${cr.type}#${f}`, {
                 state: 'Conflict',
-                // the following 2 type assertions are valid because of previous filter statement
-                // they can be removed once TS is smarter about filtering
                 fullName: cr.name,
                 type: cr.type,
                 filePath: (0, node_path_1.resolve)(f),
@@ -44,36 +44,23 @@ const findConflictsInComponentSet = (cs, conflicts) => {
     return reformattedConflicts;
 };
 exports.findConflictsInComponentSet = findConflictsInComponentSet;
-const getDedupedConflictsFromChanges = ({ localChanges = [], remoteChanges = [], projectPath, forceIgnore, }) => {
-    // index the remoteChanges by filename
-    const fileNameIndex = new Map();
-    const metadataKeyIndex = new Map();
-    remoteChanges.map((change) => {
-        if (change.name && change.type) {
-            metadataKeyIndex.set((0, functions_1.getMetadataKey)(change.name, change.type), change);
-        }
-        change.filenames?.map((filename) => {
-            fileNameIndex.set(filename, change);
-        });
-    });
-    const conflicts = new Set();
-    (0, populateTypesAndNames_1.populateTypesAndNames)({ elements: localChanges, excludeUnresolvable: true, projectPath, forceIgnore }).map((change) => {
+const getDedupedConflictsFromChanges = ({ localChanges = [], remoteChanges = [], projectPath, forceIgnore, registry, }) => {
+    const metadataKeyIndex = new Map(remoteChanges
+        .filter(guards_1.isChangeResultWithNameAndType)
+        .map((change) => [(0, functions_1.getMetadataKey)(change.name, change.type), change]));
+    const fileNameIndex = new Map(remoteChanges.flatMap((change) => (change.filenames ?? []).map((filename) => [filename, change])));
+    return (0, populateTypesAndNames_1.populateTypesAndNames)({ excludeUnresolvable: true, projectPath, forceIgnore, registry })(localChanges)
+        .filter(guards_1.isChangeResultWithNameAndType)
+        .flatMap((change) => {
         const metadataKey = (0, functions_1.getMetadataKey)(change.name, change.type);
-        // option 1: name and type match
-        if (metadataKeyIndex.has(metadataKey)) {
-            conflicts.add({ ...metadataKeyIndex.get(metadataKey) });
-        }
-        else {
-            // option 2: some of the filenames match
-            change.filenames?.map((filename) => {
-                if (fileNameIndex.has(filename)) {
-                    conflicts.add({ ...fileNameIndex.get(filename) });
-                }
-            });
-        }
+        return metadataKeyIndex.has(metadataKey)
+            ? // option 1: name and type match
+                [metadataKeyIndex.get(metadataKey)]
+            : // option 2: some of the filenames match
+                (change.filenames ?? [])
+                    .filter((filename) => fileNameIndex.has(filename))
+                    .map((filename) => fileNameIndex.get(filename));
     });
-    // deeply de-dupe
-    return Array.from(conflicts);
 };
 exports.getDedupedConflictsFromChanges = getDedupedConflictsFromChanges;
 //# sourceMappingURL=conflicts.js.map

package/lib/shared/functions.d.ts

@@ -1,16 +1,18 @@
-import { SourceComponent } from '@salesforce/source-deploy-retrieve';
-import { RemoteChangeElement, ChangeResult } from './types';
+import { FileResponseSuccess, ForceIgnore, MetadataComponent, MetadataMember, RegistryAccess, SourceComponent } from '@salesforce/source-deploy-retrieve';
+import { RemoteChangeElement, ChangeResult, ChangeResultWithNameAndType, RemoteSyncInput } from './types';
 export declare const getMetadataKey: (metadataType: string, metadataName: string) => string;
 export declare const getKeyFromObject: (element: RemoteChangeElement | ChangeResult) => string;
 export declare const supportsPartialDelete: (cmp: SourceComponent) => boolean;
-export declare const isLwcLocalOnlyTest: (filePath: string) => boolean;
+export declare const excludeLwcLocalOnlyTest: (filePath: string) => boolean;
 /**
  * Verify that a filepath starts exactly with a complete parent path
  * ex: '/foo/bar-extra/baz'.startsWith('foo/bar') would be true, but this function understands that they are not in the same folder
  */
-export declare const pathIsInFolder: (filePath: string, folder: string) => boolean;
+export declare const pathIsInFolder: (folder: string) => (filePath: string) => boolean;
+/** just like pathIsInFolder but with the parameter order reversed for iterating a single file against an array of folders */
+export declare const folderContainsPath: (filePath: string) => (folder: string) => boolean;
 export declare const chunkArray: <T>(arr: T[], size: number) => T[][];
-export declare const ensureRelative: (filePath: string, projectPath: string) => string;
+export declare const ensureRelative: (projectPath: string) => (filePath: string) => string;
 export type ParsedCustomLabels = {
     CustomLabels: {
         labels: Array<{
@@ -26,3 +28,11 @@ export type ParsedCustomLabels = {
  * @returns -json equivalent of the custom labels file's contents OR undefined if the file was deleted/not written
  */
 export declare const deleteCustomLabels: (filename: string, customLabels: SourceComponent[]) => Promise<ParsedCustomLabels | undefined>;
+/** returns true if forceIgnore denies a path OR if there is no forceIgnore provided */
+export declare const forceIgnoreDenies: (forceIgnore?: ForceIgnore) => (filePath: string) => boolean;
+export declare const sourceComponentIsCustomLabel: (input: SourceComponent) => boolean;
+export declare const sourceComponentHasFullNameAndType: (input: SourceComponent) => boolean;
+export declare const getAllFiles: (sc: SourceComponent) => string[];
+export declare const remoteChangeToMetadataMember: (cr: ChangeResult) => MetadataMember;
+export declare const FileResponseSuccessToRemoteSyncInput: (fr: FileResponseSuccess) => RemoteSyncInput;
+export declare const changeResultToMetadataComponent: (registry?: RegistryAccess) => (cr: ChangeResultWithNameAndType) => MetadataComponent;

package/lib/shared/functions.js

@@ -6,12 +6,14 @@
  * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deleteCustomLabels = exports.ensureRelative = exports.chunkArray = exports.pathIsInFolder = exports.isLwcLocalOnlyTest = exports.supportsPartialDelete = exports.getKeyFromObject = exports.getMetadataKey = void 0;
+exports.changeResultToMetadataComponent = exports.FileResponseSuccessToRemoteSyncInput = exports.remoteChangeToMetadataMember = exports.getAllFiles = exports.sourceComponentHasFullNameAndType = exports.sourceComponentIsCustomLabel = exports.forceIgnoreDenies = exports.deleteCustomLabels = exports.ensureRelative = exports.chunkArray = exports.folderContainsPath = exports.pathIsInFolder = exports.excludeLwcLocalOnlyTest = exports.supportsPartialDelete = exports.getKeyFromObject = exports.getMetadataKey = void 0;
 const node_path_1 = require("node:path");
 const fs = require("node:fs");
 const ts_types_1 = require("@salesforce/ts-types");
+const source_deploy_retrieve_1 = require("@salesforce/source-deploy-retrieve");
 const fast_xml_parser_1 = require("fast-xml-parser");
 const kit_1 = require("@salesforce/kit");
+const remoteChangeIgnoring_1 = require("./remoteChangeIgnoring");
 const getMetadataKey = (metadataType, metadataName) => `${metadataType}__${metadataName}`;
 exports.getMetadataKey = getMetadataKey;
 const getKeyFromObject = (element) => {
@@ -23,13 +25,13 @@ const getKeyFromObject = (element) => {
 exports.getKeyFromObject = getKeyFromObject;
 const supportsPartialDelete = (cmp) => !!cmp.type.supportsPartialDelete;
 exports.supportsPartialDelete = supportsPartialDelete;
-const isLwcLocalOnlyTest = (filePath) => filePath.includes('__utam__') || filePath.includes('__tests__');
-exports.isLwcLocalOnlyTest = isLwcLocalOnlyTest;
+const excludeLwcLocalOnlyTest = (filePath) => !(filePath.includes('__utam__') || filePath.includes('__tests__'));
+exports.excludeLwcLocalOnlyTest = excludeLwcLocalOnlyTest;
 /**
  * Verify that a filepath starts exactly with a complete parent path
  * ex: '/foo/bar-extra/baz'.startsWith('foo/bar') would be true, but this function understands that they are not in the same folder
  */
-const pathIsInFolder = (filePath, folder) => {
+const pathIsInFolder = (folder) => (filePath) => {
     const biggerStringParts = (0, node_path_1.normalize)(filePath).split(node_path_1.sep).filter(nonEmptyStringFilter);
     return (0, node_path_1.normalize)(folder)
         .split(node_path_1.sep)
@@ -37,11 +39,14 @@ const pathIsInFolder = (filePath, folder) => {
         .every((part, index) => part === biggerStringParts[index]);
 };
 exports.pathIsInFolder = pathIsInFolder;
+/** just like pathIsInFolder but with the parameter order reversed for iterating a single file against an array of folders */
+const folderContainsPath = (filePath) => (folder) => (0, exports.pathIsInFolder)(folder)(filePath);
+exports.folderContainsPath = folderContainsPath;
 const nonEmptyStringFilter = (value) => (0, ts_types_1.isString)(value) && value.length > 0;
 // adapted for TS from https://github.com/30-seconds/30-seconds-of-code/blob/master/snippets/chunk.md
 const chunkArray = (arr, size) => Array.from({ length: Math.ceil(arr.length / size) }, (v, i) => arr.slice(i * size, i * size + size));
 exports.chunkArray = chunkArray;
-const ensureRelative = (filePath, projectPath) => (0, node_path_1.isAbsolute)(filePath) ? (0, node_path_1.relative)(projectPath, filePath) : filePath;
+const ensureRelative = (projectPath) => (filePath) => (0, node_path_1.isAbsolute)(filePath) ? (0, node_path_1.relative)(projectPath, filePath) : filePath;
 exports.ensureRelative = ensureRelative;
 /**
  * A method to help delete custom labels from a file, or the entire file if there are no more labels
@@ -51,11 +56,9 @@ exports.ensureRelative = ensureRelative;
  * @returns -json equivalent of the custom labels file's contents OR undefined if the file was deleted/not written
  */
 const deleteCustomLabels = async (filename, customLabels) => {
-    const customLabelsToDelete = customLabels
-        .filter((label) => label.type.id === 'customlabel')
-        .map((change) => change.fullName);
+    const customLabelsToDelete = new Set(customLabels.filter(exports.sourceComponentIsCustomLabel).map((change) => change.fullName));
     // if we don't have custom labels, we don't need to do anything
-    if (!customLabelsToDelete.length) {
+    if (!customLabelsToDelete.size) {
         return undefined;
     }
     // for custom labels, we need to remove the individual label from the xml file
@@ -67,7 +70,7 @@ const deleteCustomLabels = async (filename, customLabels) => {
     });
     const cls = parser.parse(fs.readFileSync(filename, 'utf8'));
     // delete the labels from the json based on their fullName's
-    cls.CustomLabels.labels = (0, kit_1.ensureArray)(cls.CustomLabels.labels).filter((label) => !customLabelsToDelete.includes(label.fullName));
+    cls.CustomLabels.labels = (0, kit_1.ensureArray)(cls.CustomLabels.labels).filter((label) => !customLabelsToDelete.has(label.fullName));
     if (cls.CustomLabels.labels.length === 0) {
         // we've deleted everything, so let's delete the file
         await fs.promises.unlink(filename);
@@ -88,4 +91,29 @@ const deleteCustomLabels = async (filename, customLabels) => {
     }
 };
 exports.deleteCustomLabels = deleteCustomLabels;
+/** returns true if forceIgnore denies a path OR if there is no forceIgnore provided */
+const forceIgnoreDenies = (forceIgnore) => (filePath) => forceIgnore?.denies(filePath) ?? false;
+exports.forceIgnoreDenies = forceIgnoreDenies;
+const sourceComponentIsCustomLabel = (input) => input.type.name === 'CustomLabel';
+exports.sourceComponentIsCustomLabel = sourceComponentIsCustomLabel;
+const sourceComponentHasFullNameAndType = (input) => typeof input.fullName === 'string' && typeof input.type.name === 'string';
+exports.sourceComponentHasFullNameAndType = sourceComponentHasFullNameAndType;
+const getAllFiles = (sc) => [sc.xml, ...sc.walkContent()].filter(ts_types_1.isString);
+exports.getAllFiles = getAllFiles;
+const remoteChangeToMetadataMember = (cr) => {
+    const checked = (0, remoteChangeIgnoring_1.ensureNameAndType)(cr);
+    return {
+        fullName: checked.name,
+        type: checked.type,
+    };
+};
+exports.remoteChangeToMetadataMember = remoteChangeToMetadataMember;
+// weird, right?  This is for oclif.table which allows types but not interfaces.  In this case, they are equivalent
+const FileResponseSuccessToRemoteSyncInput = (fr) => fr;
+exports.FileResponseSuccessToRemoteSyncInput = FileResponseSuccessToRemoteSyncInput;
+const changeResultToMetadataComponent = (registry = new source_deploy_retrieve_1.RegistryAccess()) => (cr) => ({
+    fullName: cr.name,
+    type: registry.getTypeByName(cr.type),
+});
+exports.changeResultToMetadataComponent = changeResultToMetadataComponent;
 //# sourceMappingURL=functions.js.map

package/lib/shared/guards.d.ts

@@ -1,3 +1,11 @@
-import { SourceComponent, MetadataMember } from '@salesforce/source-deploy-retrieve';
+import { SourceComponent, MetadataMember, FileResponse, FileResponseFailure, FileResponseSuccess } from '@salesforce/source-deploy-retrieve';
+import { ChangeResult } from './types';
+import { ChangeResultWithNameAndType } from './types';
 export declare const sourceComponentGuard: (input: SourceComponent | undefined) => input is SourceComponent;
 export declare const metadataMemberGuard: (input: MetadataMember | undefined | Partial<MetadataMember>) => input is MetadataMember;
+export declare const isSdrFailure: (fileResponse: FileResponse) => fileResponse is FileResponseFailure;
+export declare const isSdrSuccess: (fileResponse: FileResponse) => fileResponse is FileResponseSuccess;
+export declare const FileResponseIsDeleted: (fileResponse: FileResponse) => boolean;
+export declare const FileResponseIsNotDeleted: (fileResponse: FileResponse) => boolean;
+export declare const FileResponseHasPath: (fileResponse: FileResponseSuccess) => fileResponse is FileResponseSuccess & Required<Pick<FileResponseSuccess, "filePath">>;
+export declare const isChangeResultWithNameAndType: (cr?: ChangeResult) => cr is ChangeResultWithNameAndType;

package/lib/shared/guards.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.metadataMemberGuard = exports.sourceComponentGuard = void 0;
+exports.isChangeResultWithNameAndType = exports.FileResponseHasPath = exports.FileResponseIsNotDeleted = exports.FileResponseIsDeleted = exports.isSdrSuccess = exports.isSdrFailure = exports.metadataMemberGuard = exports.sourceComponentGuard = void 0;
 /*
  * Copyright (c) 2020, salesforce.com, inc.
  * All rights reserved.
@@ -12,4 +12,16 @@ const sourceComponentGuard = (input) => input instanceof source_deploy_retrieve_
 exports.sourceComponentGuard = sourceComponentGuard;
 const metadataMemberGuard = (input) => input !== undefined && typeof input.fullName === 'string' && typeof input.type === 'string';
 exports.metadataMemberGuard = metadataMemberGuard;
+const isSdrFailure = (fileResponse) => fileResponse.state === source_deploy_retrieve_1.ComponentStatus.Failed;
+exports.isSdrFailure = isSdrFailure;
+const isSdrSuccess = (fileResponse) => fileResponse.state !== source_deploy_retrieve_1.ComponentStatus.Failed;
+exports.isSdrSuccess = isSdrSuccess;
+const FileResponseIsDeleted = (fileResponse) => fileResponse.state === source_deploy_retrieve_1.ComponentStatus.Deleted;
+exports.FileResponseIsDeleted = FileResponseIsDeleted;
+const FileResponseIsNotDeleted = (fileResponse) => fileResponse.state !== source_deploy_retrieve_1.ComponentStatus.Deleted;
+exports.FileResponseIsNotDeleted = FileResponseIsNotDeleted;
+const FileResponseHasPath = (fileResponse) => fileResponse.filePath !== undefined;
+exports.FileResponseHasPath = FileResponseHasPath;
+const isChangeResultWithNameAndType = (cr) => typeof cr === 'object' && typeof cr.name === 'string' && typeof cr.type === 'string';
+exports.isChangeResultWithNameAndType = isChangeResultWithNameAndType;
 //# sourceMappingURL=guards.js.map

package/lib/shared/localComponentSetArray.d.ts

@@ -1,5 +1,5 @@
 import { NamedPackageDir } from '@salesforce/core';
-import { ComponentSet } from '@salesforce/source-deploy-retrieve';
+import { ComponentSet, RegistryAccess } from '@salesforce/source-deploy-retrieve';
 interface GroupedFileInput {
     packageDirs: NamedPackageDir[];
     nonDeletes: string[];
@@ -11,5 +11,9 @@ interface GroupedFile {
     deletes: string[];
 }
 export declare const getGroupedFiles: (input: GroupedFileInput, byPackageDir?: boolean) => GroupedFile[];
-export declare const getComponentSets: (groupings: GroupedFile[], sourceApiVersion?: string) => ComponentSet[];
+export declare const getComponentSets: ({ groupings, sourceApiVersion, registry, }: {
+    groupings: GroupedFile[];
+    sourceApiVersion?: string | undefined;
+    registry: RegistryAccess;
+}) => ComponentSet[];
 export {};

package/lib/shared/localComponentSetArray.js

@@ -17,8 +17,8 @@ const getGroupedFiles = (input, byPackageDir = false) => (byPackageDir ? getSequ
 exports.getGroupedFiles = getGroupedFiles;
 const getSequential = ({ packageDirs, nonDeletes, deletes }) => packageDirs.map((pkgDir) => ({
     path: pkgDir.name,
-    nonDeletes: nonDeletes.filter((f) => (0, functions_1.pathIsInFolder)(f, pkgDir.name)),
-    deletes: deletes.filter((f) => (0, functions_1.pathIsInFolder)(f, pkgDir.name)),
+    nonDeletes: nonDeletes.filter((0, functions_1.pathIsInFolder)(pkgDir.name)),
+    deletes: deletes.filter((0, functions_1.pathIsInFolder)(pkgDir.name)),
 }));
 const getNonSequential = ({ packageDirs, nonDeletes: nonDeletes, deletes: deletes, }) => [
     {
@@ -27,20 +27,20 @@ const getNonSequential = ({ packageDirs, nonDeletes: nonDeletes, deletes: delete
         path: packageDirs.map((dir) => dir.name).join(';'),
     },
 ];
-const getComponentSets = (groupings, sourceApiVersion) => {
+const getComponentSets = ({ groupings, sourceApiVersion, registry = new source_deploy_retrieve_1.RegistryAccess(), }) => {
     const logger = core_1.Logger.childFromRoot('localComponentSetArray');
     // optimistic resolution...some files may not be possible to resolve
-    const resolverForNonDeletes = new source_deploy_retrieve_1.MetadataResolver();
+    const resolverForNonDeletes = new source_deploy_retrieve_1.MetadataResolver(registry);
     return groupings
         .map((grouping) => {
         logger.debug(`building componentSet for ${grouping.path} (deletes: ${grouping.deletes.length} nonDeletes: ${grouping.nonDeletes.length})`);
-        const componentSet = new source_deploy_retrieve_1.ComponentSet();
+        const componentSet = new source_deploy_retrieve_1.ComponentSet(undefined, registry);
         if (sourceApiVersion) {
             componentSet.sourceApiVersion = sourceApiVersion;
         }
         // we need virtual components for the deletes.
         // TODO: could we use the same for the non-deletes?
-        const resolverForDeletes = new source_deploy_retrieve_1.MetadataResolver(undefined, source_deploy_retrieve_1.VirtualTreeContainer.fromFilePaths(grouping.deletes));
+        const resolverForDeletes = new source_deploy_retrieve_1.MetadataResolver(registry, source_deploy_retrieve_1.VirtualTreeContainer.fromFilePaths(grouping.deletes));
         grouping.deletes
             .flatMap((filename) => resolverForDeletes.getComponentsFromPath(filename))
             .filter(guards_1.sourceComponentGuard)

package/lib/shared/localShadowRepo.js

@@ -38,7 +38,7 @@ class ShadowRepo {
         this.projectPath = options.projectPath;
         this.packageDirs = options.packageDirs;
         this.isWindows = os.type() === 'Windows_NT';
-        this.maxFileAdd = kit_1.env.getNumber('SF_SOURCE_TRACKING_BATCH_SIZE', kit_1.env.getNumber('SFDX_SOURCE_TRACKING_BATCH_SIZE', this.isWindows ? 8000 : 15000));
+        this.maxFileAdd = kit_1.env.getNumber('SF_SOURCE_TRACKING_BATCH_SIZE', kit_1.env.getNumber('SFDX_SOURCE_TRACKING_BATCH_SIZE', this.isWindows ? 8000 : 15_000));
     }
     // think of singleton behavior but unique to the projectPath
     static async getInstance(options) {
@@ -100,26 +100,24 @@ class ShadowRepo {
             // iso-git uses relative, posix paths
             // but packageDirs has already resolved / normalized them
             // so we need to make them project-relative again and convert if windows
-            const filepaths = this.packageDirs
-                .map((dir) => path.relative(this.projectPath, dir.fullPath))
-                .map((p) => (this.isWindows ? p.split(path.sep).join(path.posix.sep) : p));
+            const pkgDirs = this.packageDirs.map(packageDirToRelativePosixPath(this.isWindows)(this.projectPath));
             try {
                 // status hasn't been initialized yet
                 this.status = await git.statusMatrix({
                     fs,
                     dir: this.projectPath,
                     gitdir: this.gitDir,
-                    filepaths,
+                    filepaths: pkgDirs,
                     ignored: true,
                     filter: (f) => 
                     // no hidden files
                     !f.includes(`${path.sep}.`) &&
                         // no lwc tests
-                        !(0, functions_1.isLwcLocalOnlyTest)(f) &&
+                        (0, functions_1.excludeLwcLocalOnlyTest)(f) &&
                         // no gitignore files
                         !f.endsWith('.gitignore') &&
                         // isogit uses `startsWith` for filepaths so it's possible to get a false positive
-                        filepaths.some((pkgDir) => (0, functions_1.pathIsInFolder)(f, pkgDir)),
+                        pkgDirs.some((0, functions_1.folderContainsPath)(f)),
                 });
             }
             catch (e) {
@@ -198,10 +196,10 @@ class ShadowRepo {
             deletedFiles: deletedFiles.length,
         });
         // these are stored in posix/style/path format.  We have to convert inbound stuff from windows
-        if (os.type() === 'Windows_NT') {
+        if (this.isWindows) {
             this.logger.trace('start: transforming windows paths to posix');
-            deployedFiles = deployedFiles.map((filepath) => path.normalize(filepath).split(path.sep).join(path.posix.sep));
-            deletedFiles = deletedFiles.map((filepath) => path.normalize(filepath).split(path.sep).join(path.posix.sep));
+            deployedFiles = deployedFiles.map(normalize).map(ensurePosix);
+            deletedFiles = deletedFiles.map(normalize).map(ensurePosix);
             this.logger.trace('done: transforming windows paths to posix');
         }
         if (deployedFiles.length) {
@@ -266,4 +264,9 @@ class ShadowRepo {
 }
 exports.ShadowRepo = ShadowRepo;
 ShadowRepo.instanceMap = new Map();
+const packageDirToRelativePosixPath = (isWindows) => (projectPath) => (packageDir) => isWindows
+    ? ensurePosix(path.relative(projectPath, packageDir.fullPath))
+    : path.relative(projectPath, packageDir.fullPath);
+const normalize = (filepath) => path.normalize(filepath);
+const ensurePosix = (filepath) => filepath.split(path.sep).join(path.posix.sep);
 //# sourceMappingURL=localShadowRepo.js.map

package/lib/shared/metadataKeys.js

@@ -20,6 +20,7 @@ const registry = new source_deploy_retrieve_1.RegistryAccess();
 // only compute once
 const aliasTypes = registry
     .getAliasTypes()
+    // allow assertion because aliasTypes are defined as having that property
     .map((aliasType) => [aliasType.name, registry.getTypeByName(aliasType.aliasFor).name]);
 const reverseAliasTypes = new Map(aliasTypes.map(([alias, type]) => [type, alias]));
 // handle all "weird" type/name translation between SourceMember and SDR FileResponse

package/lib/shared/populateFilePaths.d.ts

@@ -1,3 +1,4 @@
+import { RegistryAccess } from '@salesforce/source-deploy-retrieve';
 import { ChangeResult } from './types';
 /**
  * Will build a component set, crawling your local directory, to get paths for remote changes
@@ -6,4 +7,8 @@ import { ChangeResult } from './types';
  * @param packageDirPaths Array of paths from PackageDirectories
  * @returns
  */
-export declare const populateFilePaths: (elements: ChangeResult[], packageDirPaths: string[]) => ChangeResult[];
+export declare const populateFilePaths: ({ elements, packageDirPaths, registry, }: {
+    elements: ChangeResult[];
+    packageDirPaths: string[];
+    registry: RegistryAccess;
+}) => ChangeResult[];

package/lib/shared/populateFilePaths.js

@@ -19,7 +19,7 @@ const functions_1 = require("./functions");
  * @param packageDirPaths Array of paths from PackageDirectories
  * @returns
  */
-const populateFilePaths = (elements, packageDirPaths) => {
+const populateFilePaths = ({ elements, packageDirPaths, registry, }) => {
     if (elements.length === 0) {
         return [];
     }
@@ -28,22 +28,17 @@ const populateFilePaths = (elements, packageDirPaths) => {
     // component set generated from an array of MetadataMember from all the remote changes
     // but exclude the ones that aren't in the registry
     const remoteChangesAsMetadataMember = elements
-        .map((element) => {
-        if (typeof element.type === 'string' && typeof element.name === 'string') {
-            return {
-                type: element.type,
-                fullName: element.name,
-            };
-        }
-    })
-        .filter(guards_1.metadataMemberGuard);
-    const remoteChangesAsComponentSet = new source_deploy_retrieve_1.ComponentSet(remoteChangesAsMetadataMember);
+        .filter(guards_1.isChangeResultWithNameAndType)
+        .map(functions_1.remoteChangeToMetadataMember);
+    const remoteChangesAsComponentSet = new source_deploy_retrieve_1.ComponentSet(remoteChangesAsMetadataMember, registry);
     logger.debug(` the generated component set has ${remoteChangesAsComponentSet.size.toString()} items`);
     if (remoteChangesAsComponentSet.size < elements.length) {
         // there *could* be something missing
         // some types (ex: LWC) show up as multiple files in the remote changes, but only one in the component set
         // iterate the elements to see which ones didn't make it into the component set
-        const missingComponents = elements.filter((element) => !remoteChangesAsComponentSet.has({ type: element?.type, fullName: element?.name }));
+        const missingComponents = elements
+            .filter(guards_1.isChangeResultWithNameAndType)
+            .filter((element) => !remoteChangesAsComponentSet.has({ type: element.type, fullName: element.name }));
         // Throw if anything was actually missing
         if (missingComponents.length > 0) {
             throw new Error(`unable to generate complete component set for ${elements
@@ -54,25 +49,28 @@ const populateFilePaths = (elements, packageDirPaths) => {
     const matchingLocalSourceComponentsSet = source_deploy_retrieve_1.ComponentSet.fromSource({
         fsPaths: packageDirPaths,
         include: remoteChangesAsComponentSet,
+        registry,
     });
     logger.debug(` local source-backed component set has ${matchingLocalSourceComponentsSet.size.toString()} items from remote`);
     // make it simpler to find things later
     const elementMap = new Map(elements.map((e) => [(0, functions_1.getKeyFromObject)(e), e]));
     // iterates the local components and sets their filenames
-    for (const matchingComponent of matchingLocalSourceComponentsSet.getSourceComponents().toArray()) {
-        if (matchingComponent.fullName && matchingComponent.type.name) {
-            logger.debug(`${matchingComponent.fullName}|${matchingComponent.type.name} matches ${matchingComponent.xml} and maybe ${matchingComponent.walkContent().toString()}`);
-            // Decode the key since local components can have encoded fullNames, but results from querying
-            // SourceMembers have fullNames that are not encoded. See:  https://github.com/forcedotcom/cli/issues/1683
-            const key = decodeURIComponent((0, functions_1.getMetadataKey)(matchingComponent.type.name, matchingComponent.fullName));
-            elementMap.set(key, {
-                ...elementMap.get(key),
-                modified: true,
-                origin: 'remote',
-                filenames: [matchingComponent.xml, ...matchingComponent.walkContent()].filter((filename) => filename),
-            });
-        }
-    }
+    matchingLocalSourceComponentsSet
+        .getSourceComponents()
+        .toArray()
+        .filter(functions_1.sourceComponentHasFullNameAndType)
+        .map((matchingComponent) => {
+        logger.debug(`${matchingComponent.fullName}|${matchingComponent.type.name} matches ${matchingComponent.xml} and maybe ${matchingComponent.walkContent().toString()}`);
+        // Decode the key since local components can have encoded fullNames, but results from querying
+        // SourceMembers have fullNames that are not encoded. See:  https://github.com/forcedotcom/cli/issues/1683
+        const key = decodeURIComponent((0, functions_1.getMetadataKey)(matchingComponent.type.name, matchingComponent.fullName));
+        elementMap.set(key, {
+            ...elementMap.get(key),
+            modified: true,
+            origin: 'remote',
+            filenames: (0, functions_1.getAllFiles)(matchingComponent),
+        });
+    });
     return Array.from(elementMap.values());
 };
 exports.populateFilePaths = populateFilePaths;

package/lib/shared/populateTypesAndNames.d.ts

@@ -1,4 +1,4 @@
-import { ForceIgnore } from '@salesforce/source-deploy-retrieve';
+import { ForceIgnore, RegistryAccess } from '@salesforce/source-deploy-retrieve';
 import { ChangeResult } from './types';
 /**
  * uses SDR to translate remote metadata records into local file paths (which only typically have the filename).
@@ -9,10 +9,10 @@ import { ChangeResult } from './types';
  * @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
  */
-export declare const populateTypesAndNames: ({ elements, projectPath, forceIgnore, excludeUnresolvable, resolveDeleted, }: {
-    elements: ChangeResult[];
+export declare const populateTypesAndNames: ({ projectPath, forceIgnore, excludeUnresolvable, resolveDeleted, registry, }: {
     projectPath: string;
     forceIgnore?: ForceIgnore | undefined;
     excludeUnresolvable?: boolean | undefined;
     resolveDeleted?: boolean | undefined;
-}) => ChangeResult[];
+    registry: RegistryAccess;
+}) => (elements: ChangeResult[]) => ChangeResult[];