feat: Test running overhaul, switch to Prettier & reformat everything (#1407)

* chore: Switch to Node 20 + Vitest

* chore: migrate to vitest mock functions

* chore: code style (switch to prettier)

* test: re-enable long-running test

Seems the switch to Node 20 and Vitest has vastly improved the code's and / or the test's runtime!

see #1193

* chore: code style

* chore: fix failing tests

* Updated Documentation in README.md

* Update contribution guidelines to state usage of Prettier

* fix: set prettier printWidth back to 80

* chore: apply updated code style automatically

* fix: set prettier line endings to lf again

* chore: apply updated code style automatically

---------

Co-authored-by: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Co-authored-by: Lars Müller <34514239+appgurueu@users.noreply.github.com>

Data-Structures/Array/LocalMaximomPoint.js

@@ -9,19 +9,38 @@
  * @complexity: O(log(n)) (worst case)
  * @flow
  */
-const findMaxPointIndex = (array, rangeStartIndex, rangeEndIndex, originalLength) => {
+const findMaxPointIndex = (
+  array,
+  rangeStartIndex,
+  rangeEndIndex,
+  originalLength
+) => {
   // find index range middle point
-  const middleIndex = rangeStartIndex + parseInt((rangeEndIndex - rangeStartIndex) / 2)
+  const middleIndex =
+    rangeStartIndex + parseInt((rangeEndIndex - rangeStartIndex) / 2)
 
   // handle array bounds
-  if ((middleIndex === 0 || array[middleIndex - 1] <= array[middleIndex]) &&
-        (middleIndex === originalLength - 1 || array[middleIndex + 1] <= array[middleIndex])) {
+  if (
+    (middleIndex === 0 || array[middleIndex - 1] <= array[middleIndex]) &&
+    (middleIndex === originalLength - 1 ||
+      array[middleIndex + 1] <= array[middleIndex])
+  ) {
     return middleIndex
   } else if (middleIndex > 0 && array[middleIndex - 1] > array[middleIndex]) {
-    return findMaxPointIndex(array, rangeStartIndex, (middleIndex - 1), originalLength)
+    return findMaxPointIndex(
+      array,
+      rangeStartIndex,
+      middleIndex - 1,
+      originalLength
+    )
   } else {
     // regular local max
-    return findMaxPointIndex(array, (middleIndex + 1), rangeEndIndex, originalLength)
+    return findMaxPointIndex(
+      array,
+      middleIndex + 1,
+      rangeEndIndex,
+      originalLength
+    )
   }
 }
 

Data-Structures/Array/NumberOfLocalMaximumPoints.js

@@ -33,10 +33,13 @@ const CountLocalMaximumPoints = (array, startIndex, endIndex) => {
 
   // handle the two halves
   const middleIndex = parseInt((startIndex + endIndex) / 2)
-  return CountLocalMaximumPoints(array, startIndex, middleIndex) +
+  return (
+    CountLocalMaximumPoints(array, startIndex, middleIndex) +
     CountLocalMaximumPoints(array, middleIndex + 1, endIndex)
+  )
 }
 
-const NumberOfLocalMaximumPoints = (A) => CountLocalMaximumPoints(A, 0, A.length - 1)
+const NumberOfLocalMaximumPoints = (A) =>
+  CountLocalMaximumPoints(A, 0, A.length - 1)
 
 export { NumberOfLocalMaximumPoints }

Data-Structures/Array/QuickSelect.js

@@ -11,7 +11,8 @@
  * @flow
  */
 
-function QuickSelect (items, kth) { // eslint-disable-line no-unused-vars
+function QuickSelect(items, kth) {
+  // eslint-disable-line no-unused-vars
   if (kth < 1 || kth > items.length) {
     throw new RangeError('Index Out of Bound')
   }
@@ -19,7 +20,7 @@ function QuickSelect (items, kth) { // eslint-disable-line no-unused-vars
   return RandomizedSelect(items, 0, items.length - 1, kth)
 }
 
-function RandomizedSelect (items, left, right, i) {
+function RandomizedSelect(items, left, right, i) {
   if (left === right) return items[left]
 
   const pivotIndex = RandomizedPartition(items, left, right)
@@ -31,13 +32,13 @@ function RandomizedSelect (items, left, right, i) {
   return RandomizedSelect(items, pivotIndex + 1, right, i - k)
 }
 
-function RandomizedPartition (items, left, right) {
+function RandomizedPartition(items, left, right) {
   const rand = getRandomInt(left, right)
   Swap(items, rand, right)
   return Partition(items, left, right)
 }
 
-function Partition (items, left, right) {
+function Partition(items, left, right) {
   const x = items[right]
   let pivotIndex = left - 1
 
@@ -53,12 +54,12 @@ function Partition (items, left, right) {
   return pivotIndex + 1
 }
 
-function getRandomInt (min, max) {
+function getRandomInt(min, max) {
   return Math.floor(Math.random() * (max - min + 1)) + min
 }
 
-function Swap (arr, x, y) {
-  [arr[x], arr[y]] = [arr[y], arr[x]]
+function Swap(arr, x, y) {
+  ;[arr[x], arr[y]] = [arr[y], arr[x]]
 }
 
 export { QuickSelect }

Data-Structures/Array/test/Reverse.test.js

@@ -1,13 +1,14 @@
 import { Reverse } from '../Reverse.js'
-import each from 'jest-each'
 
 describe('reverse elements in an array', () => {
-  each`
-  array | expected
-  ${[]} | ${[]}
-  ${[1]} | ${[1]}
-  ${[1, 2, 3, 4]} | ${[4, 3, 2, 1]}
-  `.test('returns $expected when given $array', ({ array, expected }) => {
-      expect(Reverse(array)).toEqual(expected)
-    })
+  it.each([
+    [[], []],
+    [[1], [1]],
+    [
+      [1, 2, 3, 4],
+      [4, 3, 2, 1]
+    ]
+  ])('returns %j when given %j', (array, expected) => {
+    expect(Reverse(array)).toEqual(expected)
+  })
 })