Add processInChunks function to process files in chunks

__tests__/utils.test.ts

@@ -1,6 +1,11 @@
 import fs from 'fs';
 import path from 'path';
-import { getFiles, isValidEncoding, replaceTextInFile } from '../src/utils';
+import {
+  getFiles,
+  isValidEncoding,
+  processInChunks,
+  replaceTextInFile,
+} from '../src/utils';
 
 describe('isValidEncoding', () => {
   it('should return true for valid encodings', () => {
@@ -29,6 +34,33 @@ describe('getFiles', () => {
   });
 });
 
+describe('processInChunks', () => {
+  it('should process an array in chunks', async () => {
+    const totalItems = 999;
+    const array = Array.from({ length: totalItems }, (_, i) => i);
+    const func = jest.fn(async (item: number) => {
+      item++;
+    });
+    const chunkSize = 100;
+
+    await processInChunks(array, func, chunkSize);
+
+    expect(func).toHaveBeenCalledTimes(totalItems);
+  });
+
+  it('should process an array with less items than chunk size', async () => {
+    const array = Array.from({ length: 50 }, (_, i) => i);
+    const func = jest.fn(async (item: number) => {
+      item++;
+    });
+    const chunkSize = 100;
+
+    await processInChunks(array, func, chunkSize);
+
+    expect(func).toHaveBeenCalledTimes(50);
+  });
+});
+
 describe('replaceTextInFile', () => {
   const testFilePath = path.join(__dirname, 'test-file.txt');
   const testFileContent = '{0}, world!';

src/main.ts

@@ -3,22 +3,29 @@ import {
   Encoding,
   getFiles,
   isValidEncoding,
+  processInChunks,
   replaceTextInFile,
 } from './utils';
 
+// Entry point for the action
 async function run(): Promise<void> {
   try {
+    // Get the input parameters
     const filesPattern = getInput('files');
     const searchText = getInput('search-text');
     const replaceText = getInput('replacement-text');
     const excludePattern = getInput('exclude');
     const inputEncoding = getInput('encoding');
 
+    // Validate the encoding
     if (!isValidEncoding(inputEncoding)) {
       throw new Error(`Invalid encoding: ${inputEncoding}`);
     }
 
+    // Get the file paths that match the files pattern and do not match the exclude pattern
     const filePaths = await getFiles(filesPattern, excludePattern);
+
+    // If no file paths were found, log a warning and exit
     if (filePaths.length === 0) {
       warning(`No files found for the given pattern.`);
       return;
@@ -28,14 +35,19 @@ async function run(): Promise<void> {
     info(`Replacing "${searchText}" with "${replaceText}".`);
 
     const encoding = inputEncoding as Encoding;
-    const promises: Promise<void>[] = filePaths.map(
+
+    // Process the file paths in chunks, replacing the search text with the replace text in each file
+    // This is done to avoid opening too many files at once
+    const chunkSize = 10;
+    await processInChunks(
+      filePaths,
       async (filePath: string) => {
         info(`Replacing text in file ${filePath}`);
         await replaceTextInFile(filePath, searchText, replaceText, encoding);
       },
+      chunkSize,
     );
 
-    await Promise.all(promises);
     info(`Done!`);
   } catch (err) {
     if (err instanceof Error) {

src/utils.ts

@@ -39,6 +39,30 @@ export async function getFiles(
   }
 }
 
+/**
+ * Processes an array in chunks, applying a given function to each item.
+ * @param array The array to process.
+ * @param func The function to apply to each item.
+ * @param chunkSize The number of items to process at a time.
+ * @returns A Promise that resolves when all items have been processed.
+ */
+export async function processInChunks<T>(
+  array: T[],
+  func: (item: T) => Promise<void>,
+  chunkSize: number,
+): Promise<void> {
+  // Split the array into chunks
+  const chunks = Array(Math.ceil(array.length / chunkSize))
+    .fill(0)
+    .map((_, index) => index * chunkSize)
+    .map(begin => array.slice(begin, begin + chunkSize));
+
+  // Process each chunk
+  for (const chunk of chunks) {
+    await Promise.all(chunk.map(func));
+  }
+}
+
 /**
  * Replaces all instances of the given text with the given value in the file.
  * @param filePath The path of the file to modify.