perf: use flatmap

Author: mshanemc

src/commands/force/source/status.ts

@@ -80,11 +80,9 @@ export default class SourceStatus extends SfdxCommand {
         excludeUnresolvable: true,
       });
 
-      outputRows = outputRows.concat(localAdds.map((item) => this.statusResultToOutputRows(item, 'add')).flat());
-      outputRows = outputRows.concat(
-        localModifies.map((item) => this.statusResultToOutputRows(item, 'changed')).flat()
-      );
-      outputRows = outputRows.concat(localDeletes.map((item) => this.statusResultToOutputRows(item, 'delete')).flat());
+      outputRows = outputRows.concat(localAdds.flatMap((item) => this.statusResultToOutputRows(item, 'add')));
+      outputRows = outputRows.concat(localModifies.flatMap((item) => this.statusResultToOutputRows(item, 'changed')));
+      outputRows = outputRows.concat(localDeletes.flatMap((item) => this.statusResultToOutputRows(item, 'delete')));
     }
 
     if (this.flags.remote || this.flags.all || (!this.flags.local && !this.flags.all)) {
@@ -94,8 +92,8 @@ export default class SourceStatus extends SfdxCommand {
         tracking.getChanges<ChangeResult>({ origin: 'remote', state: 'delete', format: 'ChangeResult' }),
         tracking.getChanges<ChangeResult>({ origin: 'remote', state: 'nondelete', format: 'ChangeResult' }),
       ]);
-      outputRows = outputRows.concat(remoteDeletes.map((item) => this.statusResultToOutputRows(item)).flat());
-      outputRows = outputRows.concat(remoteModifies.map((item) => this.statusResultToOutputRows(item)).flat());
+      outputRows = outputRows.concat(remoteDeletes.flatMap((item) => this.statusResultToOutputRows(item)));
+      outputRows = outputRows.concat(remoteModifies.flatMap((item) => this.statusResultToOutputRows(item)));
     }
 
     if (!this.flags.local && !this.flags.remote) {

src/shared/remoteSourceTrackingService.ts

@@ -202,22 +202,20 @@ export class RemoteSourceTrackingService extends ConfigFile<RemoteSourceTracking
     // this can be super-repetitive on a large ExperienceBundle where there is an element for each file but only one Revision for the entire bundle
     // any item in an aura/LWC bundle needs to represent the top (bundle) level and the file itself
     // so we de-dupe via a set
-    Array.from(new Set(elements.map((element) => getMetadataKeyFromFileResponse(element)).flat())).map(
-      (metadataKey) => {
-        const revision = revisions[metadataKey];
-        if (revision && revision.lastRetrievedFromServer !== revision.serverRevisionCounter) {
-          if (!quiet) {
-            this.logger.debug(
-              `Syncing ${metadataKey} revision from ${revision.lastRetrievedFromServer} to ${revision.serverRevisionCounter}`
-            );
-          }
-          revision.lastRetrievedFromServer = revision.serverRevisionCounter;
-          this.setMemberRevision(metadataKey, revision);
-        } else {
-          this.logger.warn(`found no matching revision for ${metadataKey}`);
+    Array.from(new Set(elements.flatMap((element) => getMetadataKeyFromFileResponse(element)))).map((metadataKey) => {
+      const revision = revisions[metadataKey];
+      if (revision && revision.lastRetrievedFromServer !== revision.serverRevisionCounter) {
+        if (!quiet) {
+          this.logger.debug(
+            `Syncing ${metadataKey} revision from ${revision.lastRetrievedFromServer} to ${revision.serverRevisionCounter}`
+          );
         }
+        revision.lastRetrievedFromServer = revision.serverRevisionCounter;
+        this.setMemberRevision(metadataKey, revision);
+      } else {
+        this.logger.warn(`found no matching revision for ${metadataKey}`);
       }
-    );
+    });
 
     await this.write();
   }

src/sourceTracking.ts

@@ -125,21 +125,19 @@ export class SourceTracking extends AsyncCreatable {
     const resolverForDeletes = new MetadataResolver(undefined, filenamesToVirtualTree(deletes));
 
     nonDeletes
-      .map((filename) => {
+      .flatMap((filename) => {
         try {
           return resolverForNonDeletes.getComponentsFromPath(filename);
         } catch (e) {
           this.logger.warn(`unable to resolve ${filename}`);
           return undefined;
         }
       })
-      .flat()
       .filter(sourceComponentGuard)
       .map((component) => componentSet.add(component));
 
     deletes
-      .map((filename) => resolverForDeletes.getComponentsFromPath(filename))
-      .flat()
+      .flatMap((filename) => resolverForDeletes.getComponentsFromPath(filename))
       .filter(sourceComponentGuard)
       .map((component) => componentSet.add(component, true));
 
@@ -189,26 +187,23 @@ export class SourceTracking extends AsyncCreatable {
     if (changesToDelete.length > 0) {
       // build a component set of the deleted types
       const changesToDeleteWithFilePaths = this.populateFilePaths(changesToDelete);
-      deletesAsFileResponse = changesToDeleteWithFilePaths
-        .map((changeResult) =>
-          changeResult && changeResult.filenames
-            ? changeResult.filenames.map(
-                (filename) =>
-                  ({
-                    type: changeResult.type,
-                    fullName: changeResult.name as string,
-                    filePath: filename,
-                    state: ComponentStatus.Deleted,
-                  } as FileResponse) // this assertion is because it matches the unexported Success flavor of FileResponse
-              )
-            : []
-        )
-        .flat();
+      deletesAsFileResponse = changesToDeleteWithFilePaths.flatMap((changeResult) =>
+        changeResult && changeResult.filenames
+          ? changeResult.filenames.map(
+              (filename) =>
+                ({
+                  type: changeResult.type,
+                  fullName: changeResult.name as string,
+                  filePath: filename,
+                  state: ComponentStatus.Deleted,
+                } as FileResponse) // this assertion is because it matches the unexported Success flavor of FileResponse
+            )
+          : []
+      );
       // delete the files
       const filenames = changesToDeleteWithFilePaths
         // TODO: test that this works for undefined, string and string[]
-        .map((change) => change.filenames as string[])
-        .flat()
+        .flatMap((change) => change.filenames as string[])
         .filter(Boolean);
       await Promise.all(filenames.map((filename) => fs.promises.unlink(filename)));
       await Promise.all([
@@ -303,15 +298,14 @@ export class SourceTracking extends AsyncCreatable {
             : new MetadataResolver();
 
         return filenames
-          .map((filename) => {
+          .flatMap((filename) => {
             try {
               return resolver.getComponentsFromPath(filename);
             } catch (e) {
               this.logger.warn(`unable to resolve ${filename}`);
               return undefined;
             }
           })
-          .flat()
           .filter(sourceComponentGuard) as T[];
       }
     }
@@ -471,23 +465,19 @@ export class SourceTracking extends AsyncCreatable {
     }
 
     this.logger.debug(`populateTypesAndNames for ${elements.length} change elements`);
-    const filenames = elements
-      .map((element) => element.filenames)
-      .flat()
-      .filter(stringGuard);
+    const filenames = elements.flatMap((element) => element.filenames).filter(stringGuard);
 
     // component set generated from the filenames on all local changes
     const resolver = new MetadataResolver(undefined, resolveDeleted ? filenamesToVirtualTree(filenames) : undefined);
     const sourceComponents = filenames
-      .map((filename) => {
+      .flatMap((filename) => {
         try {
           return resolver.getComponentsFromPath(filename);
         } catch (e) {
           this.logger.warn(`unable to resolve ${filename}`);
           return undefined;
         }
       })
-      .flat()
       .filter(sourceComponentGuard);
 
     this.logger.debug(` matching SourceComponents have ${sourceComponents.length} items from local`);