infra(unicorn): no-array-reduce (#2479)

.eslintrc.js

@@ -50,7 +50,6 @@ module.exports = defineConfig({
     'unicorn/consistent-function-scoping': 'off',
     'unicorn/import-style': 'off',
     'unicorn/no-array-callback-reference': 'off',
-    'unicorn/no-array-reduce': 'off',
     'unicorn/no-await-expression-member': 'off',
     'unicorn/no-object-as-default-parameter': 'off',
     'unicorn/no-useless-switch-case': 'off',

scripts/apidoc/writer.ts

@@ -63,20 +63,17 @@ export async function writeApiDocsModule(
     text: moduleName,
     link: `/api/${lowerModuleName}.html`,
     methods,
-    diff: methods.reduce(
-      (data, method) => ({
-        ...data,
-        [method.name]: methodDiffHash(method),
+    diff: {
+      moduleHash: diffHash({
+        name: moduleName,
+        field: lowerModuleName,
+        deprecated,
+        comment,
       }),
-      {
-        moduleHash: diffHash({
-          name: moduleName,
-          field: lowerModuleName,
-          deprecated,
-          comment,
-        }),
-      }
-    ),
+      ...Object.fromEntries(
+        methods.map((method) => [method.name, methodDiffHash(method)])
+      ),
+    },
   };
 }
 

src/internal/group-by.ts

@@ -0,0 +1,25 @@
+/**
+ * Groups the values by the key function.
+ *
+ * @internal
+ *
+ * @param values The values to group.
+ * @param keyFunction The function to get the key from the value.
+ */
+export function groupBy<TValue>(
+  values: ReadonlyArray<TValue>,
+  keyFunction: (value: TValue) => string | number
+): Record<string, TValue[]> {
+  const result: Record<string, TValue[]> = {};
+
+  for (const value of values) {
+    const key = keyFunction(value);
+    if (result[key] === undefined) {
+      result[key] = [];
+    }
+
+    result[key].push(value);
+  }
+
+  return result;
+}

src/modules/word/filter-word-list-by-length.ts

@@ -1,4 +1,5 @@
 import { FakerError } from '../../errors/faker-error';
+import { groupBy } from '../../internal/group-by';
 
 /**
  * The error handling strategies for the `filterWordListByLength` function.
@@ -13,14 +14,7 @@ const STRATEGIES = {
     wordList: ReadonlyArray<string>,
     length: { min: number; max: number }
   ): string[] => {
-    const wordsByLength = wordList.reduce<Record<number, string[]>>(
-      (data, word) => {
-        (data[word.length] = data[word.length] ?? []).push(word);
-        return data;
-      },
-      {}
-    );
-
+    const wordsByLength = groupBy(wordList, (word) => word.length);
     const lengths = Object.keys(wordsByLength).map(Number);
     const min = Math.min(...lengths);
     const max = Math.max(...lengths);

test/all-functional.spec.ts

@@ -10,12 +10,36 @@ const IGNORED_MODULES = new Set([
   '_defaultRefDate',
 ]);
 
-function isTestableModule(mod: string) {
-  return !IGNORED_MODULES.has(mod);
+function getMethodNamesByModules(faker: Faker): { [module: string]: string[] } {
+  return Object.fromEntries(
+    Object.keys(faker)
+      .filter(isTestableModule)
+      .sort()
+      .map<[string, string[]]>((moduleName) => [
+        moduleName,
+        getMethodNamesOf(faker[moduleName]),
+      ])
+      .filter(([module, methods]) => {
+        if (methods.length === 0) {
+          console.log(`Skipping ${module} - No testable methods`);
+          return false;
+        }
+
+        return true;
+      })
+  );
+}
+
+function isTestableModule(moduleName: string): moduleName is keyof Faker {
+  return !IGNORED_MODULES.has(moduleName);
+}
+
+function getMethodNamesOf(module: object): string[] {
+  return Object.keys(module).filter(isMethodOf(module));
 }
 
-function isMethodOf(mod: string) {
-  return (meth: string) => typeof fakerEN[mod][meth] === 'function';
+function isMethodOf(module: object): (method: string) => boolean {
+  return (method: string) => typeof module[method] === 'function';
 }
 
 type SkipConfig<TModule> = Partial<
@@ -53,36 +77,17 @@ const BROKEN_LOCALE_METHODS = {
 };
 
 function isWorkingLocaleForMethod(
-  mod: string,
-  meth: string,
+  module: string,
+  method: string,
   locale: string
 ): boolean {
-  const broken = BROKEN_LOCALE_METHODS[mod]?.[meth] ?? [];
+  const broken = BROKEN_LOCALE_METHODS[module]?.[method] ?? [];
   return broken !== '*' && !broken.includes(locale);
 }
 
 // Basic smoke tests to make sure each method is at least implemented and returns a value.
 
-function modulesList(): { [module: string]: string[] } {
-  const modules = Object.keys(fakerEN)
-    .sort()
-    .filter(isTestableModule)
-    .reduce((result, mod) => {
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-      const methods = Object.keys(fakerEN[mod]).filter(isMethodOf(mod));
-      if (methods.length > 0) {
-        result[mod] = methods;
-      } else {
-        console.log(`Skipping ${mod} - No testable methods`);
-      }
-
-      return result;
-    }, {});
-
-  return modules;
-}
-
-const modules = modulesList();
+const modules = getMethodNamesByModules(fakerEN);
 
 describe('BROKEN_LOCALE_METHODS test', () => {
   it('should not contain obsolete configuration (modules)', () => {

test/scripts/apidoc/verify-jsdoc-tags.spec.ts

@@ -47,28 +47,24 @@ describe('verify JSDoc tags', () => {
   }
 
   const allowedReferences = new Set(
-    Object.values(modules).reduce<string[]>((acc, [module, methods]) => {
+    Object.values(modules).flatMap(([module, methods]) => {
       const moduleFieldName = extractModuleFieldName(module);
-      return [
-        ...acc,
-        ...Object.keys(methods).map(
-          (methodName) => `faker.${moduleFieldName}.${methodName}`
-        ),
-      ];
-    }, [])
+      return Object.keys(methods).map(
+        (methodName) => `faker.${moduleFieldName}.${methodName}`
+      );
+    })
   );
   const allowedLinks = new Set(
-    Object.values(modules).reduce<string[]>((acc, [module, methods]) => {
+    Object.values(modules).flatMap(([module, methods]) => {
       const moduleFieldName = extractModuleFieldName(module);
       return [
-        ...acc,
         `/api/${moduleFieldName}.html`,
         ...Object.keys(methods).map(
           (methodName) =>
             `/api/${moduleFieldName}.html#${methodName.toLowerCase()}`
         ),
       ];
-    }, [])
+    })
   );
 
   function assertDescription(description: string, isHtml: boolean): void {