From d28195e4c94e46b300153e3a32a9f88121a44dbe Mon Sep 17 00:00:00 2001 From: tabcat Date: Sun, 21 Apr 2024 22:09:00 -0700 Subject: [PATCH] chore: apply formatting --- src/difference.ts | 13 +++++++++---- src/union.ts | 4 ++-- src/util.ts | 26 +++++++++++++++++--------- test/helpers/sets.ts | 5 +++-- test/util.test.ts | 40 +++++++++++++++++++++++++++------------- 5 files changed, 58 insertions(+), 30 deletions(-) diff --git a/src/difference.ts b/src/difference.ts index ff4348e..467c87b 100644 --- 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( export function* symmetric( minuend: T[], subtrahend: T[], - comparator: (a: T, b: T) => number + comparator: (a: T, b: T) => number, ): Generator { for (const [s, t] of diff(minuend, subtrahend, comparator)) { yield (s ?? t)!; @@ -67,11 +72,11 @@ export type Diff = [T, null] | [null, T]; export function* diff( source: T[], target: T[], - comparator: (a: T, b: T) => number + comparator: (a: T, b: T) => number, ): Generator> { for (const [s, t] of pairwiseTraversal(source, target, comparator)) { if (s === null || t === null) { - yield [s, t] as Diff + yield [s, t] as Diff; } } } diff --git a/src/union.ts b/src/union.ts index 9174a25..d1c4a3b 100644 --- a/src/union.ts +++ b/src/union.ts @@ -13,6 +13,6 @@ export function* union( comparator: (a: T, b: T) => number, ): Generator { 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 index 5b9f474..34db8e1 100644 --- a/src/util.ts +++ b/src/util.ts @@ -135,25 +135,31 @@ export function* readArray( } } -export type PairwiseElement = [T, null] | [null, T] | [T, T] +export type PairwiseElement = [T, null] | [null, T] | [T, T]; -export function* pairwiseTraversal (source: T[], target: T[], comparator: (a: T, b: T) => number,): Generator> { +export function* pairwiseTraversal( + source: T[], + target: T[], + comparator: (a: T, b: T) => number, +): Generator> { 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 (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 index a62e8a4..5d5a8e4 100644 --- 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 index da287d5..ff16784 100644 --- 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]), + ); }); }); });