Fix handling zero

arogozine · arogozine · commit 9f6fc3bac2f4 · 2022-08-18T16:47:06.000-06:00
diff --git a/src/async/_private/firstOrDefault.ts b/src/async/_private/firstOrDefault.ts
@@ -11,7 +11,7 @@ export const firstOrDefault = <TSource>(
 const firstOrDefault1 = async <T>(source: AsyncIterable<T>) => {
     const first = await source[Symbol.asyncIterator]().next()
     // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    return first.value || null
+    return first.value ?? null
 }
 
 const firstOrDefault2 = async <T>(
diff --git a/src/async/_private/max.ts b/src/async/_private/max.ts
@@ -18,7 +18,7 @@ export const max: MaxFunc = <TSource>(
 const max1 = async (source: AsyncIterable<number>) => {
     let maxItem: number | null = null
     for await (const item of source) {
-        maxItem = Math.max(maxItem || Number.NEGATIVE_INFINITY, item)
+        maxItem = Math.max(maxItem ?? Number.NEGATIVE_INFINITY, item)
     }
 
     if (maxItem === null) {
@@ -32,7 +32,7 @@ const max2 = async <TSource>(
     source: AsyncIterable<TSource>, selector: (x: TSource) => number) => {
     let maxItem: number | null = null
     for await (const item of source) {
-        maxItem = Math.max(maxItem || Number.NEGATIVE_INFINITY, selector(item))
+        maxItem = Math.max(maxItem ?? Number.NEGATIVE_INFINITY, selector(item))
     }
 
     if (maxItem === null) {
diff --git a/src/async/_private/maxAsync.ts b/src/async/_private/maxAsync.ts
@@ -4,7 +4,7 @@ export const maxAsync = async <TSource>(
     source: AsyncIterable<TSource>, selector: (x: TSource) => Promise<number>): Promise<number> => {
     let max: number | null = null
     for await (const item of source) {
-        max = Math.max(max || Number.NEGATIVE_INFINITY, await selector(item))
+        max = Math.max(max ?? Number.NEGATIVE_INFINITY, await selector(item))
     }
 
     if (max === null) {
diff --git a/src/async/_private/min.ts b/src/async/_private/min.ts
@@ -16,7 +16,7 @@ export const min: MinAsync = (source: AsyncIterable<number>, selector?: (x: numb
 const min1 = async (source: AsyncIterable<number>) => {
     let minValue: number | null = null
     for await (const item of source) {
-        minValue = Math.min(minValue || Number.POSITIVE_INFINITY, item)
+        minValue = Math.min(minValue ?? Number.POSITIVE_INFINITY, item)
     }
 
     if (minValue === null) {
@@ -29,7 +29,7 @@ const min1 = async (source: AsyncIterable<number>) => {
 const min2 = async (source: AsyncIterable<number>, selector: (x: number) => number) => {
     let minValue: number | null = null
     for await (const item of source) {
-        minValue = Math.min(minValue || Number.POSITIVE_INFINITY, selector(item))
+        minValue = Math.min(minValue ?? Number.POSITIVE_INFINITY, selector(item))
     }
 
     if (minValue === null) {
diff --git a/src/async/_private/minAsync.ts b/src/async/_private/minAsync.ts
@@ -5,7 +5,7 @@ export const minAsync = async <TSource>(
     selector: (x: TSource) => Promise<number>): Promise<number> => {
     let min: number | null = null
     for await (const item of source) {
-        min = Math.min(min || Number.POSITIVE_INFINITY, await selector(item))
+        min = Math.min(min ?? Number.POSITIVE_INFINITY, await selector(item))
     }
 
     if (min === null) {
diff --git a/src/initializer/bindArrayEnumerable.ts b/src/initializer/bindArrayEnumerable.ts
@@ -47,7 +47,7 @@ export const bindArrayEnumerable = <T, TKey extends keyof IEnumerable<T>>() => {
         return this[index] as T
     }
     prototype.elementAtOrDefault = function(index: number): T | null {
-        return (this[index] as T | undefined) || null
+        return (this[index] as T | undefined) ?? null
     }
     prototype.first = function(predicate?: (x: T) => boolean): T {
         if (predicate) {
diff --git a/src/sync/_private/firstOrDefault.ts b/src/sync/_private/firstOrDefault.ts
@@ -10,7 +10,7 @@ export const firstOrDefault = <TSource>(
 const firstOrDefault1 = <T>(source: Iterable<T>): T | null => {
     const first = source[Symbol.iterator]().next()
     // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    return first.value || null
+    return first.value ?? null
 }
 
 const firstOrDefault2 = <T>(source: Iterable<T>, predicate: (x: T) => boolean): T | null => {
diff --git a/src/sync/_private/max.ts b/src/sync/_private/max.ts
@@ -18,7 +18,7 @@ export const max: MaxFunc = <TSource>(
 const max1 = (source: Iterable<number>): number => {
     let maxItem: number | null = null
     for (const item of source) {
-        maxItem = Math.max(maxItem || Number.NEGATIVE_INFINITY, item)
+        maxItem = Math.max(maxItem ?? Number.NEGATIVE_INFINITY, item)
     }
 
     if (maxItem === null) {
@@ -31,7 +31,7 @@ const max1 = (source: Iterable<number>): number => {
 const max2 = <TSource>(source: Iterable<TSource>, selector: (x: TSource) => number): number => {
     let maxItem: number | null = null
     for (const item of source) {
-        maxItem = Math.max(maxItem || Number.NEGATIVE_INFINITY, selector(item))
+        maxItem = Math.max(maxItem ?? Number.NEGATIVE_INFINITY, selector(item))
     }
 
     if (maxItem === null) {
diff --git a/src/sync/_private/maxAsync.ts b/src/sync/_private/maxAsync.ts
@@ -4,7 +4,7 @@ export const maxAsync = async <TSource>(
     source: Iterable<TSource>, selector: (x: TSource) => Promise<number>): Promise<number> => {
     let max: number | null = null
     for (const item of source) {
-        max = Math.max(max || Number.NEGATIVE_INFINITY, await selector(item))
+        max = Math.max(max ?? Number.NEGATIVE_INFINITY, await selector(item))
     }
 
     if (max === null) {
diff --git a/src/sync/_private/min.ts b/src/sync/_private/min.ts
@@ -17,7 +17,7 @@ export const min: MinFunc = <TSource>(source: Iterable<TSource> | Iterable<numbe
 const min1 = (source: Iterable<number>) => {
     let minItem: number | null = null
     for (const item of source) {
-        minItem = Math.min(minItem || Number.POSITIVE_INFINITY, item)
+        minItem = Math.min(minItem ?? Number.POSITIVE_INFINITY, item)
     }
 
     if (minItem === null) {
@@ -30,7 +30,7 @@ const min1 = (source: Iterable<number>) => {
 const min2 = <TSource>(source: Iterable<TSource>, selector: (x: TSource) => number) => {
     let minItem: number | null = null
     for (const item of source) {
-        minItem = Math.min(minItem || Number.POSITIVE_INFINITY, selector(item))
+        minItem = Math.min(minItem ?? Number.POSITIVE_INFINITY, selector(item))
     }
 
     if (minItem === null) {
diff --git a/src/sync/_private/minAsync.ts b/src/sync/_private/minAsync.ts
@@ -4,7 +4,7 @@ export const minAsync = async <TSource>(
     source: Iterable<TSource>, selector: (x: TSource) => Promise<number>): Promise<number> => {
     let min: number | null = null
     for (const item of source) {
-        min = Math.min(min || Number.POSITIVE_INFINITY, await selector(item))
+        min = Math.min(min ?? Number.POSITIVE_INFINITY, await selector(item))
     }
 
     if (min === null) {
diff --git a/tests/unittests/tests/ElementAtOrDefault.ts b/tests/unittests/tests/ElementAtOrDefault.ts
@@ -3,6 +3,9 @@ import { asAsync, expectAsync, itAsync, itEnumerable, itParallel } from "../Test
 describe("elementAtOrDefault", () => {
 
     it("String", () => {
+        expect("0".elementAtOrDefault(0)).toBe("0")
+        expect("".elementAtOrDefault(0)).toBeNull()
+
         expect("abc".elementAtOrDefault(0)).toBe("a")
         expect("abc".elementAtOrDefault(1)).toBe("b")
         expect("abc".elementAtOrDefault(2)).toBe("c")
@@ -25,6 +28,21 @@ describe("elementAtOrDefault", () => {
         expect(await asParallel([1, 2]).elementAtOrDefault(1)).toBe(2)
     })
 
+    itEnumerable("Starting with Zero", (asEnumerable) => {
+        expect(asEnumerable([0]).elementAtOrDefault(0)).toBe(0)
+        expect(asEnumerable([0, 2]).elementAtOrDefault(1)).toBe(2)
+    })
+
+    itAsync("Starting with Zero", async () => {
+        expect(await asAsync([0]).elementAtOrDefault(0)).toBe(0)
+        expect(await asAsync([0, 2]).elementAtOrDefault(1)).toBe(2)
+    })
+
+    itParallel("Starting with Zero", async (asParallel) => {
+        expect(await asParallel([0]).elementAtOrDefault(0)).toBe(0)
+        expect(await asParallel([0, 2]).elementAtOrDefault(1)).toBe(2)
+    })
+
     itEnumerable("Empty to be null", (asEnumerable) =>
         expect(asEnumerable([]).elementAtOrDefault(0)).toBeNull())
 
diff --git a/tests/unittests/tests/Max.ts b/tests/unittests/tests/Max.ts
@@ -35,6 +35,18 @@ describe("max", () => {
 
     itParallel("Basic", async (asParallel) => expect(await asParallel([1, 2, 3]).max()).toBe(3))
 
+    itEnumerable("Max Zero", (asEnumerable) => {
+        expect(asEnumerable([0, -1]).max()).toBe(0)
+    })
+
+    itAsync("Max Zero", async () => {
+        expect(await asAsync([0, -1]).max()).toBe(0)
+    })
+
+    itParallel("Max Zero", async (asParallel) => {
+        expect(await asParallel([0, -1]).max()).toBe(0)
+    })
+
     itEnumerable("empty array throws exception", (asEnumerable) =>
         expect(() => asEnumerable([]).max()).toThrowError(InvalidOperationException))
 
diff --git a/tests/unittests/tests/Min.ts b/tests/unittests/tests/Min.ts
@@ -14,6 +14,18 @@ describe("min", () => {
         expect(await asParallel([1, 2, 3, -7]).min()).toBe(-7)
     })
 
+    itEnumerable("Min Zero", (asEnumerable) => {
+        expect(asEnumerable([1, 2, 0, 1, 3, 4, 9, 8, 5]).min()).toBe(0)
+    })
+
+    itAsync("Min Zero", async () => {
+        expect(await asAsync([1, 2, 0, 1, 3, 4, 9, 8, 5]).min()).toBe(0)
+    })
+
+    itParallel("Min Zero", async (asParallel) => {
+        expect(await asParallel([1, 2, 0, 1, 3, 4, 9, 8, 5]).min()).toBe(0)
+    })
+
     itEnumerable("MinEmptyError", (asEnumerable) => {
         expect(() => asEnumerable([]).min()).toThrowError(InvalidOperationException)
     })
@@ -56,6 +68,20 @@ describe("min", () => {
         expectMin.toBe(1)
     })
 
+    itEnumerable("Min Predicate Zero", (asEnumerable) => {
+        expect(asEnumerable([1, 2, 0, 1, 3, 4, 9, 8, 5]).min(Math.abs)).toBe(0)
+    })
+
+    itAsync("Min Predicate Zero", async () => {
+        const expectMin = await expectAsync(asAsync([1, 2, 0, 1, 3, 4, 9, 8, 5]).min(Math.abs))
+        expectMin.toBe(0)
+    })
+
+    itParallel("Min Predicate Zero", async (asParallel) => {
+        const expectMin = await expectAsync(asParallel([1, 2, 0, 1, 3, 4, 9, 8, 5]).min(Math.abs))
+        expectMin.toBe(0)
+    })
+
     itEnumerable("empty exception", (asEnumerable) => {
         expect(() => asEnumerable([]).min()).toThrowError(InvalidOperationException)
     })
diff --git a/tests/unittests/tests/MinAsync.ts b/tests/unittests/tests/MinAsync.ts
@@ -24,7 +24,7 @@ describe("minAsync", () => {
     })
 
     itAsync("Min Predicate", async () => {
-        const expectMin = await expectAsync(asAsync([1, 2, 3, -7]).min(Math.abs))
+        const expectMin = await expectAsync(asAsync([1, 2, 3, -7]).minAsync(async (x) => Math.abs(x)))
         expectMin.toBe(1)
     })
 

Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ export const firstOrDefault = <TSource>(`
`11`	`11`	`const firstOrDefault1 = async <T>(source: AsyncIterable<T>) => {`
`12`	`12`	`const first = await source[Symbol.asyncIterator]().next()`
`13`	`13`	`// eslint-disable-next-line @typescript-eslint/no-unsafe-return`
`14`		`- return first.value \|\| null`
	`14`	`+ return first.value ?? null`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`const firstOrDefault2 = async <T>(`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@ export const maxAsync = async <TSource>(`
`4`	`4`	`source: AsyncIterable<TSource>, selector: (x: TSource) => Promise<number>): Promise<number> => {`
`5`	`5`	`let max: number \| null = null`
`6`	`6`	`for await (const item of source) {`
`7`		`- max = Math.max(max \|\| Number.NEGATIVE_INFINITY, await selector(item))`
	`7`	`+ max = Math.max(max ?? Number.NEGATIVE_INFINITY, await selector(item))`
`8`	`8`	`}`
`9`	`9`
`10`	`10`	`if (max === null) {`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ export const minAsync = async <TSource>(`
`5`	`5`	`selector: (x: TSource) => Promise<number>): Promise<number> => {`
`6`	`6`	`let min: number \| null = null`
`7`	`7`	`for await (const item of source) {`
`8`		`- min = Math.min(min \|\| Number.POSITIVE_INFINITY, await selector(item))`
	`8`	`+ min = Math.min(min ?? Number.POSITIVE_INFINITY, await selector(item))`
`9`	`9`	`}`
`10`	`10`
`11`	`11`	`if (min === null) {`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ export const bindArrayEnumerable = <T, TKey extends keyof IEnumerable<T>>() => {`
`47`	`47`	`return this[index] as T`
`48`	`48`	`}`
`49`	`49`	`prototype.elementAtOrDefault = function(index: number): T \| null {`
`50`		`- return (this[index] as T \| undefined) \|\| null`
	`50`	`+ return (this[index] as T \| undefined) ?? null`
`51`	`51`	`}`
`52`	`52`	`prototype.first = function(predicate?: (x: T) => boolean): T {`
`53`	`53`	`if (predicate) {`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ export const firstOrDefault = <TSource>(`
`10`	`10`	`const firstOrDefault1 = <T>(source: Iterable<T>): T \| null => {`
`11`	`11`	`const first = source[Symbol.iterator]().next()`
`12`	`12`	`// eslint-disable-next-line @typescript-eslint/no-unsafe-return`
`13`		`- return first.value \|\| null`
	`13`	`+ return first.value ?? null`
`14`	`14`	`}`
`15`	`15`
`16`	`16`	`const firstOrDefault2 = <T>(source: Iterable<T>, predicate: (x: T) => boolean): T \| null => {`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@ export const maxAsync = async <TSource>(`
`4`	`4`	`source: Iterable<TSource>, selector: (x: TSource) => Promise<number>): Promise<number> => {`
`5`	`5`	`let max: number \| null = null`
`6`	`6`	`for (const item of source) {`
`7`		`- max = Math.max(max \|\| Number.NEGATIVE_INFINITY, await selector(item))`
	`7`	`+ max = Math.max(max ?? Number.NEGATIVE_INFINITY, await selector(item))`
`8`	`8`	`}`
`9`	`9`
`10`	`10`	`if (max === null) {`