chore: apply formatting

tabcat · Apr 22, 2024 · d28195e · d28195e
1 parent 231a9b7
commit d28195e
Show file tree

Hide file tree

Showing 5 changed files with 58 additions and 30 deletions.
diff --git a/src/difference.ts b/src/difference.ts
@@ -1,4 +1,9 @@
-import { safeArrayAccess, dualTraversal, readArray, pairwiseTraversal } from "./util.js";
+import {
+  safeArrayAccess,
+  dualTraversal,
+  readArray,
+  pairwiseTraversal,
+} from "./util.js";
 
 /**
  * Yields the difference of two ordered sets.
@@ -48,7 +53,7 @@ export function* difference<T>(
 export function* symmetric<T>(
   minuend: T[],
   subtrahend: T[],
-  comparator: (a: T, b: T) => number
+  comparator: (a: T, b: T) => number,
 ): Generator<T> {
   for (const [s, t] of diff(minuend, subtrahend, comparator)) {
     yield (s ?? t)!;
@@ -67,11 +72,11 @@ export type Diff<T> = [T, null] | [null, T];
 export function* diff<T>(
   source: T[],
   target: T[],
-  comparator: (a: T, b: T) => number
+  comparator: (a: T, b: T) => number,
 ): Generator<Diff<T>> {
   for (const [s, t] of pairwiseTraversal(source, target, comparator)) {
     if (s === null || t === null) {
-      yield [s, t] as Diff<T>
+      yield [s, t] as Diff<T>;
     }
   }
 }
diff --git a/src/union.ts b/src/union.ts
@@ -13,6 +13,6 @@ export function* union<T>(
   comparator: (a: T, b: T) => number,
 ): Generator<T> {
   for (const [s, t] of pairwiseTraversal(source, target, comparator)) {
-    yield (s ?? t)!
-   }
+    yield (s ?? t)!;
+  }
 }
diff --git a/src/util.ts b/src/util.ts
@@ -135,25 +135,31 @@ export function* readArray<T>(
   }
 }
 
-export type PairwiseElement<T> = [T, null] | [null, T] | [T, T]
+export type PairwiseElement<T> = [T, null] | [null, T] | [T, T];
 
-export function* pairwiseTraversal <T>(source: T[], target: T[], comparator: (a: T, b: T) => number,): Generator<PairwiseElement<T>> {
+export function* pairwiseTraversal<T>(
+  source: T[],
+  target: T[],
+  comparator: (a: T, b: T) => number,
+): Generator<PairwiseElement<T>> {
   for (const [i, j, order] of dualTraversal(source, target, comparator)) {
     switch (true) {
       case order < 0:
         yield [safeArrayAccess(source, i), null];
-        break
+        break;
       case order > 0:
         yield [null, safeArrayAccess(target, j)];
-        break
+        break;
       default: // order === 0
-        yield [safeArrayAccess(source, i), safeArrayAccess(target, j)]
+        yield [safeArrayAccess(source, i), safeArrayAccess(target, j)];
     }
 
     // if source is exausted
     if (order <= 0 && i === source.length - 1) {
-      if (j >= 0) { // j could be -1
-        if (order < 0) { // if order is not equal then also yield target[j]
+      if (j >= 0) {
+        // j could be -1
+        if (order < 0) {
+          // if order is not equal then also yield target[j]
           yield [null, safeArrayAccess(target, j)];
         }
 
@@ -169,8 +175,10 @@ export function* pairwiseTraversal <T>(source: T[], target: T[], comparator: (a:
 
     // if target is exausted
     if (order >= 0 && j === target.length - 1) {
-      if (i >= 0) { // i could be -1
-        if (order > 0) { // if order is not equal then also yield source[i]
+      if (i >= 0) {
+        // i could be -1
+        if (order > 0) {
+          // if order is not equal then also yield source[i]
           yield [safeArrayAccess(source, i), null];
         }
 

diff --git a/test/helpers/sets.ts b/test/helpers/sets.ts
@@ -1,6 +1,7 @@
-export const createNumbers = (n: number): number[] => new Array(n).fill(1).map((_v, i) => i)
+export const createNumbers = (n: number): number[] =>
+  new Array(n).fill(1).map((_v, i) => i);
 
-export const numbers: number[] = createNumbers(8)
+export const numbers: number[] = createNumbers(8);
 
 export const even: number[] = numbers.filter((x) => x % 2 === 0);
 

diff --git a/test/util.test.ts b/test/util.test.ts
@@ -2,7 +2,13 @@ import { describe, test, expect } from "vitest";
 import { numbers, even, odd, comparator } from "./helpers/sets.js";
 import { isGenerator } from "./helpers/isGenerator.js";
 import { testNames } from "./helpers/test-names.js";
-import { safeArrayAccess, dualTraversal, readArray, pairwiseTraversal, PairwiseElement } from "../src/util.js";
+import {
+  safeArrayAccess,
+  dualTraversal,
+  readArray,
+  pairwiseTraversal,
+  PairwiseElement,
+} from "../src/util.js";
 
 describe("safeArrayAccess", () => {
   test("returns array[index]", () => {
@@ -215,27 +221,31 @@ describe("pairwiseTraversal", () => {
         expect(element[1]).toBeGreaterThanOrEqual(0);
         u.push(element);
       }
-      expect(u).toEqual(numbers.map(n => [null, n]));
+      expect(u).toEqual(numbers.map((n) => [null, n]));
     });
 
     test(testNames.secondEmpty, () => {
       g = pairwiseTraversal(numbers, [], comparator);
       u = [];
       for (const element of g) {
-        expect(element[1]).toBe(null)
+        expect(element[1]).toBe(null);
         u.push(element);
       }
-      expect(u).toEqual(numbers.map(n => [n, null]));
+      expect(u).toEqual(numbers.map((n) => [n, null]));
     });
 
     test(testNames.identicalSingle, () => {
-      g = pairwiseTraversal(numbers.slice(0, 1), numbers.slice(0, 1), comparator);
+      g = pairwiseTraversal(
+        numbers.slice(0, 1),
+        numbers.slice(0, 1),
+        comparator,
+      );
       u = [];
       for (const element of g) {
         expect(element[0]).toEqual(element[1]);
         u.push(element);
       }
-      expect(u).toEqual(numbers.slice(0, 1).map(n => [n, n]));
+      expect(u).toEqual(numbers.slice(0, 1).map((n) => [n, n]));
     });
 
     test(testNames.identical, () => {
@@ -245,7 +255,7 @@ describe("pairwiseTraversal", () => {
         expect(element[0]).toEqual(element[1]);
         u.push(element);
       }
-      expect(u).toEqual(numbers.map(n => [n, n]));
+      expect(u).toEqual(numbers.map((n) => [n, n]));
     });
 
     test(testNames.partialOverlap, () => {
@@ -254,30 +264,34 @@ describe("pairwiseTraversal", () => {
       for (const element of g) {
         u.push(element);
       }
-      expect(u).toEqual(numbers.map(n => [n, n % 2 === 0 ? n : null]));
+      expect(u).toEqual(numbers.map((n) => [n, n % 2 === 0 ? n : null]));
 
       g = pairwiseTraversal(numbers, odd, comparator);
       u = [];
       for (const element of g) {
         u.push(element);
       }
-      expect(u).toEqual(numbers.map(n => [n, n % 2 === 1 ? n : null]));
+      expect(u).toEqual(numbers.map((n) => [n, n % 2 === 1 ? n : null]));
     });
 
     test(testNames.noOverlap, () => {
       g = pairwiseTraversal(even, odd, comparator);
       u = [];
       for (const element of g) {
-        u.push(element)
+        u.push(element);
       }
-      expect(u).toEqual(numbers.map(n => [n % 2 === 0 ? n : null, n % 2 === 1 ? n : null]));
+      expect(u).toEqual(
+        numbers.map((n) => [n % 2 === 0 ? n : null, n % 2 === 1 ? n : null]),
+      );
 
       g = pairwiseTraversal(odd, even, comparator);
       u = [];
       for (const element of g) {
-        u.push(element)
+        u.push(element);
       }
-      expect(u).toEqual(numbers.map(n => [n % 2 === 1 ? n : null, n % 2 === 0 ? n : null]));
+      expect(u).toEqual(
+        numbers.map((n) => [n % 2 === 1 ? n : null, n % 2 === 0 ? n : null]),
+      );
     });
   });
 });