Fix handling zero

Author: arogozine

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>(

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) {

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) {

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) {

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) {

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) {

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 => {

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) {

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) {

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) {

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) {

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())
 

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))
 

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)
     })

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)
     })