complete-common 2.12.0 → 2.14.0

package/dist/functions/array.d.cts

@@ -51,6 +51,20 @@ export declare function arrayRemoveAllInPlace<T>(array: T[], ...elementsToRemove
 export declare function arrayRemoveInPlace<T>(array: T[], ...elementsToRemove: readonly T[]): readonly T[];
 /** Helper function to remove all of the elements in an array in-place. */
 export declare function emptyArray(array: unknown[]): void;
+/**
+ * Helper function to perform an asynchronous filter. The vanilla `Array.filter` method does not
+ * wait for promises (and treats them as truthy), so this function runs the predicate on all
+ * elements concurrently, awaits the results, and then filters the original array.
+ *
+ * Usage:
+ *
+ * ```ts
+ * const results = await filterAsync(things, async (thing) => await filterFunc(thing));
+ * ```
+ *
+ * (This is an abstraction around `Promise.all`.)
+ */
+export declare function filterAsync<T>(array: readonly T[], predicate: (element: T, index: number, array: readonly T[]) => Promise<boolean>): Promise<readonly T[]>;
 /**
  * Helper function to perform a filter and a map at the same time. Similar to `Array.map`, provide a
  * function that transforms a value, but return `undefined` if the value should be skipped. (Thus,
@@ -82,7 +96,7 @@ export declare function filterMap<OldT, NewT>(array: readonly OldT[], func: (ele
  *
  * (This is an abstraction around `Promise.all`.)
  */
-export declare function filterMapAsync<OldT, NewT>(array: readonly OldT[], func: (element: OldT) => Promise<NewT | undefined>): Promise<readonly NewT[]>;
+export declare function filterMapAsync<OldT, NewT>(array: readonly OldT[], func: (element: OldT, index: number, array: readonly OldT[]) => Promise<NewT | undefined>): Promise<readonly NewT[]>;
 /**
  * Helper function to get a random element from the provided array.
  *
@@ -122,6 +136,23 @@ export declare function isArrayBoolean(variable: unknown): variable is boolean[]
 export declare function isArrayNumber(variable: unknown): variable is number[];
 /** Helper function to check every value of an array to see if it is a string. */
 export declare function isArrayString(variable: unknown): variable is string[];
+/**
+ * Helper function to perform an asynchronous map. The vanilla `Array.map` method does not wait for
+ * promises, resulting in an array of promises rather than the resolved values. This function runs
+ * the callback on all elements concurrently, awaits the results, and returns the mapped array.
+ *
+ * You can also use this function to simply run an asynchronous function on each element of an array
+ * concurrently.
+ *
+ * Usage:
+ *
+ * ```ts
+ * const results = await mapAsync(things, async (thing) => await mapFunc(thing));
+ * ```
+ *
+ * (This is an abstraction around `Promise.all`.)
+ */
+export declare function mapAsync<T, U>(array: readonly T[], callback: (element: T, index: number, array: readonly T[]) => Promise<U>): Promise<readonly U[]>;
 /** Initializes an array with all elements containing the specified default value. */
 export declare function newArray<T>(length: number, value: T): readonly T[];
 /** Helper function to sum every value in an array together. */

package/dist/functions/array.d.mts

@@ -51,6 +51,20 @@ export declare function arrayRemoveAllInPlace<T>(array: T[], ...elementsToRemove
 export declare function arrayRemoveInPlace<T>(array: T[], ...elementsToRemove: readonly T[]): readonly T[];
 /** Helper function to remove all of the elements in an array in-place. */
 export declare function emptyArray(array: unknown[]): void;
+/**
+ * Helper function to perform an asynchronous filter. The vanilla `Array.filter` method does not
+ * wait for promises (and treats them as truthy), so this function runs the predicate on all
+ * elements concurrently, awaits the results, and then filters the original array.
+ *
+ * Usage:
+ *
+ * ```ts
+ * const results = await filterAsync(things, async (thing) => await filterFunc(thing));
+ * ```
+ *
+ * (This is an abstraction around `Promise.all`.)
+ */
+export declare function filterAsync<T>(array: readonly T[], predicate: (element: T, index: number, array: readonly T[]) => Promise<boolean>): Promise<readonly T[]>;
 /**
  * Helper function to perform a filter and a map at the same time. Similar to `Array.map`, provide a
  * function that transforms a value, but return `undefined` if the value should be skipped. (Thus,
@@ -82,7 +96,7 @@ export declare function filterMap<OldT, NewT>(array: readonly OldT[], func: (ele
  *
  * (This is an abstraction around `Promise.all`.)
  */
-export declare function filterMapAsync<OldT, NewT>(array: readonly OldT[], func: (element: OldT) => Promise<NewT | undefined>): Promise<readonly NewT[]>;
+export declare function filterMapAsync<OldT, NewT>(array: readonly OldT[], func: (element: OldT, index: number, array: readonly OldT[]) => Promise<NewT | undefined>): Promise<readonly NewT[]>;
 /**
  * Helper function to get a random element from the provided array.
  *
@@ -122,6 +136,23 @@ export declare function isArrayBoolean(variable: unknown): variable is boolean[]
 export declare function isArrayNumber(variable: unknown): variable is number[];
 /** Helper function to check every value of an array to see if it is a string. */
 export declare function isArrayString(variable: unknown): variable is string[];
+/**
+ * Helper function to perform an asynchronous map. The vanilla `Array.map` method does not wait for
+ * promises, resulting in an array of promises rather than the resolved values. This function runs
+ * the callback on all elements concurrently, awaits the results, and returns the mapped array.
+ *
+ * You can also use this function to simply run an asynchronous function on each element of an array
+ * concurrently.
+ *
+ * Usage:
+ *
+ * ```ts
+ * const results = await mapAsync(things, async (thing) => await mapFunc(thing));
+ * ```
+ *
+ * (This is an abstraction around `Promise.all`.)
+ */
+export declare function mapAsync<T, U>(array: readonly T[], callback: (element: T, index: number, array: readonly T[]) => Promise<U>): Promise<readonly U[]>;
 /** Initializes an array with all elements containing the specified default value. */
 export declare function newArray<T>(length: number, value: T): readonly T[];
 /** Helper function to sum every value in an array together. */

package/dist/functions/array.d.ts

@@ -51,6 +51,20 @@ export declare function arrayRemoveAllInPlace<T>(array: T[], ...elementsToRemove
 export declare function arrayRemoveInPlace<T>(array: T[], ...elementsToRemove: readonly T[]): readonly T[];
 /** Helper function to remove all of the elements in an array in-place. */
 export declare function emptyArray(array: unknown[]): void;
+/**
+ * Helper function to perform an asynchronous filter. The vanilla `Array.filter` method does not
+ * wait for promises (and treats them as truthy), so this function runs the predicate on all
+ * elements concurrently, awaits the results, and then filters the original array.
+ *
+ * Usage:
+ *
+ * ```ts
+ * const results = await filterAsync(things, async (thing) => await filterFunc(thing));
+ * ```
+ *
+ * (This is an abstraction around `Promise.all`.)
+ */
+export declare function filterAsync<T>(array: readonly T[], predicate: (element: T, index: number, array: readonly T[]) => Promise<boolean>): Promise<readonly T[]>;
 /**
  * Helper function to perform a filter and a map at the same time. Similar to `Array.map`, provide a
  * function that transforms a value, but return `undefined` if the value should be skipped. (Thus,
@@ -82,7 +96,7 @@ export declare function filterMap<OldT, NewT>(array: readonly OldT[], func: (ele
  *
  * (This is an abstraction around `Promise.all`.)
  */
-export declare function filterMapAsync<OldT, NewT>(array: readonly OldT[], func: (element: OldT) => Promise<NewT | undefined>): Promise<readonly NewT[]>;
+export declare function filterMapAsync<OldT, NewT>(array: readonly OldT[], func: (element: OldT, index: number, array: readonly OldT[]) => Promise<NewT | undefined>): Promise<readonly NewT[]>;
 /**
  * Helper function to get a random element from the provided array.
  *
@@ -122,6 +136,23 @@ export declare function isArrayBoolean(variable: unknown): variable is boolean[]
 export declare function isArrayNumber(variable: unknown): variable is number[];
 /** Helper function to check every value of an array to see if it is a string. */
 export declare function isArrayString(variable: unknown): variable is string[];
+/**
+ * Helper function to perform an asynchronous map. The vanilla `Array.map` method does not wait for
+ * promises, resulting in an array of promises rather than the resolved values. This function runs
+ * the callback on all elements concurrently, awaits the results, and returns the mapped array.
+ *
+ * You can also use this function to simply run an asynchronous function on each element of an array
+ * concurrently.
+ *
+ * Usage:
+ *
+ * ```ts
+ * const results = await mapAsync(things, async (thing) => await mapFunc(thing));
+ * ```
+ *
+ * (This is an abstraction around `Promise.all`.)
+ */
+export declare function mapAsync<T, U>(array: readonly T[], callback: (element: T, index: number, array: readonly T[]) => Promise<U>): Promise<readonly U[]>;
 /** Initializes an array with all elements containing the specified default value. */
 export declare function newArray<T>(length: number, value: T): readonly T[];
 /** Helper function to sum every value in an array together. */

package/dist/functions/array.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../src/functions/array.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../src/functions/array.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAI7D;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,EACvC,KAAK,EAAE,aAAa,CAAC,SAAS,CAAC,EAAE,CAAC,GACjC,aAAa,CAAC,SAAS,CAAC,EAAE,CAAC,CAQ7B;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAC3B,MAAM,EAAE,SAAS,CAAC,EAAE,EACpB,MAAM,EAAE,SAAS,CAAC,EAAE,GACnB,OAAO,CAST;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAC3B,aAAa,EAAE,SAAS,CAAC,EAAE,EAC3B,GAAG,gBAAgB,EAAE,SAAS,CAAC,EAAE,GAChC,SAAS,CAAC,EAAE,CAWd;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAErC,KAAK,EAAE,CAAC,EAAE,EACV,GAAG,gBAAgB,EAAE,SAAS,CAAC,EAAE,GAChC,OAAO,CAeT;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAElC,KAAK,EAAE,CAAC,EAAE,EACV,GAAG,gBAAgB,EAAE,SAAS,CAAC,EAAE,GAChC,SAAS,CAAC,EAAE,CAYd;AAED,0EAA0E;AAE1E,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,IAAI,CAEjD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,WAAW,CAAC,CAAC,EACjC,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,SAAS,EAAE,CACT,OAAO,EAAE,CAAC,EACV,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,SAAS,CAAC,EAAE,KAChB,OAAO,CAAC,OAAO,CAAC,GACpB,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,CAMvB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,IAAI,EAClC,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,IAAI,EAAE,CAAC,OAAO,EAAE,IAAI,KAAK,IAAI,GAAG,SAAS,GACxC,SAAS,IAAI,EAAE,CAWjB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,cAAc,CAAC,IAAI,EAAE,IAAI,EAC7C,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,IAAI,EAAE,CACJ,OAAO,EAAE,IAAI,EACb,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,SAAS,IAAI,EAAE,KACnB,OAAO,CAAC,IAAI,GAAG,SAAS,CAAC,GAC7B,OAAO,CAAC,SAAS,IAAI,EAAE,CAAC,CAM1B;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EACrC,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,UAAU,GAAE,SAAS,CAAC,EAAO,GAC5B,CAAC,CAiBH;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,SAAS,OAAO,EAAE,EACzB,UAAU,GAAE,SAAS,MAAM,EAAO,GACjC,MAAM,CAQR;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,YAAY,SAAS,YAAY,CAAC,CAAC,CAAC,EAC9D,KAAK,EAAE,SAAS,YAAY,EAAE,EAC9B,aAAa,EAAE,YAAY,CAAC,CAAC,CAAC,GAC7B,aAAa,IAAI,YAAY,CAG/B;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAC3B,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,GAAG,cAAc,EAAE,SAAS,CAAC,EAAE,GAC9B,OAAO,CAET;AAED,uFAAuF;AACvF,wBAAgB,OAAO,CAAC,QAAQ,EAAE,OAAO,GAAG,QAAQ,IAAI,OAAO,EAAE,CAEhE;AAED,kFAAkF;AAClF,wBAAgB,cAAc,CAAC,QAAQ,EAAE,OAAO,GAAG,QAAQ,IAAI,OAAO,EAAE,CAMvE;AAED,iFAAiF;AACjF,wBAAgB,aAAa,CAAC,QAAQ,EAAE,OAAO,GAAG,QAAQ,IAAI,MAAM,EAAE,CAMrE;AAED,iFAAiF;AACjF,wBAAgB,aAAa,CAAC,QAAQ,EAAE,OAAO,GAAG,QAAQ,IAAI,MAAM,EAAE,CAMrE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,QAAQ,CAAC,CAAC,EAAE,CAAC,EACjC,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,QAAQ,EAAE,CAAC,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,KAAK,OAAO,CAAC,CAAC,CAAC,GACvE,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,CAKvB;AAED,qFAAqF;AACrF,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,SAAS,CAAC,EAAE,CAElE;AAED,+DAA+D;AAC/D,wBAAgB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAEzD"}

package/dist/index.cjs

@@ -188,6 +188,12 @@ function arrayRemoveInPlace(array, ...elementsToRemove) {
 function emptyArray(array) {
   array.splice(0);
 }
+async function filterAsync(array, predicate) {
+  const results = await Promise.all(
+    array.map(async (element, index) => await predicate(element, index, array))
+  );
+  return array.filter((_, index) => results[index] === true);
+}
 function filterMap(array, func) {
   const filteredArray = [];
   for (const element of array) {
@@ -199,7 +205,9 @@ function filterMap(array, func) {
   return filteredArray;
 }
 async function filterMapAsync(array, func) {
-  const promises = array.map(async (element) => await func(element));
+  const promises = array.map(
+    async (element, index) => await func(element, index, array)
+  );
   const results = await Promise.all(promises);
   return results.filter((item) => item !== void 0);
 }
@@ -254,6 +262,12 @@ function isArrayString(variable) {
   }
   return variable.every((element) => typeof element === "string");
 }
+async function mapAsync(array, callback) {
+  const promises = array.map(
+    async (element, index) => await callback(element, index, array)
+  );
+  return await Promise.all(promises);
+}
 function newArray(length, value) {
   return Array.from({ length }, () => value);
 }
@@ -626,6 +640,7 @@ exports.copySet = copySet;
 exports.eRange = eRange;
 exports.emptyArray = emptyArray;
 exports.escapeHTMLCharacters = escapeHTMLCharacters;
+exports.filterAsync = filterAsync;
 exports.filterMap = filterMap;
 exports.filterMapAsync = filterMapAsync;
 exports.getElapsedSeconds = getElapsedSeconds;
@@ -658,6 +673,7 @@ exports.isSemanticVersion = isSemanticVersion;
 exports.isUpperCase = isUpperCase;
 exports.kebabCaseToCamelCase = kebabCaseToCamelCase;
 exports.kebabCaseToPascalCase = kebabCaseToPascalCase;
+exports.mapAsync = mapAsync;
 exports.mapFilter = mapFilter;
 exports.mapFind = mapFind;
 exports.newArray = newArray;

package/dist/index.mjs

@@ -186,6 +186,12 @@ function arrayRemoveInPlace(array, ...elementsToRemove) {
 function emptyArray(array) {
   array.splice(0);
 }
+async function filterAsync(array, predicate) {
+  const results = await Promise.all(
+    array.map(async (element, index) => await predicate(element, index, array))
+  );
+  return array.filter((_, index) => results[index] === true);
+}
 function filterMap(array, func) {
   const filteredArray = [];
   for (const element of array) {
@@ -197,7 +203,9 @@ function filterMap(array, func) {
   return filteredArray;
 }
 async function filterMapAsync(array, func) {
-  const promises = array.map(async (element) => await func(element));
+  const promises = array.map(
+    async (element, index) => await func(element, index, array)
+  );
   const results = await Promise.all(promises);
   return results.filter((item) => item !== void 0);
 }
@@ -252,6 +260,12 @@ function isArrayString(variable) {
   }
   return variable.every((element) => typeof element === "string");
 }
+async function mapAsync(array, callback) {
+  const promises = array.map(
+    async (element, index) => await callback(element, index, array)
+  );
+  return await Promise.all(promises);
+}
 function newArray(length, value) {
   return Array.from({ length }, () => value);
 }
@@ -591,4 +605,4 @@ function* tupleKeys(tuple) {
 
 const ReadonlyMap = Map;
 
-export { HOUR_IN_MILLISECONDS, MINUTE_IN_MILLISECONDS, ReadonlyMap, ReadonlySet, SECOND_IN_MILLISECONDS, addSetsToSet, arrayCopyTwoDimensional, arrayEquals, arrayRemove, arrayRemoveAllInPlace, arrayRemoveInPlace, assertArray, assertArrayBoolean, assertArrayNumber, assertArrayObject, assertArrayString, assertBoolean, assertDefined, assertEnumValue, assertInteger, assertIs, assertNotNull, assertNumber, assertObject, assertString, assertStringNotEmpty, capitalizeFirstLetter, clamp, combineSets, copySet, eRange, emptyArray, escapeHTMLCharacters, filterMap, filterMapAsync, getElapsedSeconds, getEnumEntries, getEnumKeys, getEnumValues, getNumConsecutiveDiacritics, getRandomArrayElement, getRandomArrayIndex, getRandomInt, hasDiacritic, hasEmoji, hasWhitespace, iRange, includes, includesAny, interfaceSatisfiesEnum, isASCII, isArray, isArrayBoolean, isArrayNumber, isArrayString, isEnumValue, isFirstLetterCapitalized, isKebabCase, isKeyOf, isLowerCase, isObject, isSemanticVersion, isUpperCase, kebabCaseToCamelCase, kebabCaseToPascalCase, mapFilter, mapFind, newArray, noop, normalizeString, objectFilter, objectKeysToSet, objectToMap, objectToReverseMap, objectValuesToSet, parseFloatSafe, parseIntSafe, parseSemanticVersion, removeLinesBetweenMarkers, removeLinesMatching, removeNonPrintableCharacters, removeWhitespace, repeat, setAdd, setHas, sortCaseInsensitive, sumArray, todo, trimPrefix, trimSuffix, truncateString, tupleEntries, tupleKeys };
+export { HOUR_IN_MILLISECONDS, MINUTE_IN_MILLISECONDS, ReadonlyMap, ReadonlySet, SECOND_IN_MILLISECONDS, addSetsToSet, arrayCopyTwoDimensional, arrayEquals, arrayRemove, arrayRemoveAllInPlace, arrayRemoveInPlace, assertArray, assertArrayBoolean, assertArrayNumber, assertArrayObject, assertArrayString, assertBoolean, assertDefined, assertEnumValue, assertInteger, assertIs, assertNotNull, assertNumber, assertObject, assertString, assertStringNotEmpty, capitalizeFirstLetter, clamp, combineSets, copySet, eRange, emptyArray, escapeHTMLCharacters, filterAsync, filterMap, filterMapAsync, getElapsedSeconds, getEnumEntries, getEnumKeys, getEnumValues, getNumConsecutiveDiacritics, getRandomArrayElement, getRandomArrayIndex, getRandomInt, hasDiacritic, hasEmoji, hasWhitespace, iRange, includes, includesAny, interfaceSatisfiesEnum, isASCII, isArray, isArrayBoolean, isArrayNumber, isArrayString, isEnumValue, isFirstLetterCapitalized, isKebabCase, isKeyOf, isLowerCase, isObject, isSemanticVersion, isUpperCase, kebabCaseToCamelCase, kebabCaseToPascalCase, mapAsync, mapFilter, mapFind, newArray, noop, normalizeString, objectFilter, objectKeysToSet, objectToMap, objectToReverseMap, objectValuesToSet, parseFloatSafe, parseIntSafe, parseSemanticVersion, removeLinesBetweenMarkers, removeLinesMatching, removeNonPrintableCharacters, removeWhitespace, repeat, setAdd, setHas, sortCaseInsensitive, sumArray, todo, trimPrefix, trimSuffix, truncateString, tupleEntries, tupleKeys };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "complete-common",
-  "version": "2.12.0",
+  "version": "2.14.0",
   "description": "Helper functions for TypeScript projects.",
   "homepage": "https://complete-ts.github.io/",
   "bugs": {
@@ -35,7 +35,7 @@
     "complete-node": "16.2.0",
     "eslint-plugin-sort-exports": "0.9.1",
     "typescript": "5.9.3",
-    "typescript-eslint": "8.51.0",
+    "typescript-eslint": "8.52.0",
     "unbuild": "3.6.1"
   }
 }

package/src/functions/array.ts

@@ -136,6 +136,34 @@ export function emptyArray(array: unknown[]): void {
   array.splice(0);
 }
 
+/**
+ * Helper function to perform an asynchronous filter. The vanilla `Array.filter` method does not
+ * wait for promises (and treats them as truthy), so this function runs the predicate on all
+ * elements concurrently, awaits the results, and then filters the original array.
+ *
+ * Usage:
+ *
+ * ```ts
+ * const results = await filterAsync(things, async (thing) => await filterFunc(thing));
+ * ```
+ *
+ * (This is an abstraction around `Promise.all`.)
+ */
+export async function filterAsync<T>(
+  array: readonly T[],
+  predicate: (
+    element: T,
+    index: number,
+    array: readonly T[],
+  ) => Promise<boolean>,
+): Promise<readonly T[]> {
+  const results = await Promise.all(
+    array.map(async (element, index) => await predicate(element, index, array)),
+  );
+
+  return array.filter((_, index) => results[index] === true);
+}
+
 /**
  * Helper function to perform a filter and a map at the same time. Similar to `Array.map`, provide a
  * function that transforms a value, but return `undefined` if the value should be skipped. (Thus,
@@ -184,9 +212,15 @@ export function filterMap<OldT, NewT>(
  */
 export async function filterMapAsync<OldT, NewT>(
   array: readonly OldT[],
-  func: (element: OldT) => Promise<NewT | undefined>,
+  func: (
+    element: OldT,
+    index: number,
+    array: readonly OldT[],
+  ) => Promise<NewT | undefined>,
 ): Promise<readonly NewT[]> {
-  const promises = array.map(async (element) => await func(element));
+  const promises = array.map(
+    async (element, index) => await func(element, index, array),
+  );
   const results = await Promise.all(promises);
   return results.filter((item) => item !== undefined);
 }
@@ -300,6 +334,32 @@ export function isArrayString(variable: unknown): variable is string[] {
   return variable.every((element) => typeof element === "string");
 }
 
+/**
+ * Helper function to perform an asynchronous map. The vanilla `Array.map` method does not wait for
+ * promises, resulting in an array of promises rather than the resolved values. This function runs
+ * the callback on all elements concurrently, awaits the results, and returns the mapped array.
+ *
+ * You can also use this function to simply run an asynchronous function on each element of an array
+ * concurrently.
+ *
+ * Usage:
+ *
+ * ```ts
+ * const results = await mapAsync(things, async (thing) => await mapFunc(thing));
+ * ```
+ *
+ * (This is an abstraction around `Promise.all`.)
+ */
+export async function mapAsync<T, U>(
+  array: readonly T[],
+  callback: (element: T, index: number, array: readonly T[]) => Promise<U>,
+): Promise<readonly U[]> {
+  const promises = array.map(
+    async (element, index) => await callback(element, index, array),
+  );
+  return await Promise.all(promises);
+}
+
 /** Initializes an array with all elements containing the specified default value. */
 export function newArray<T>(length: number, value: T): readonly T[] {
   return Array.from({ length }, () => value);