Merge pull request #11 from ilteoood/feat/defaultTo

feat: defaultTo

Author: ilteoood

README.md

@@ -66,6 +66,20 @@ concat(
 ```
 </details>
 
+<details>
+<summary>defaultTo</summary>
+
+```javascript
+import { defaultTo } from '@ilteoood/re-flusso/defaultTo';
+
+await pipeline(
+    fromIterable([null, undefined]),
+    defaultTo(1),
+    toIterable([])
+)
+```
+</details>
+
 <details>
 <summary>text</summary>
 

src/defaultTo.ts

@@ -0,0 +1,13 @@
+import { map } from "./map";
+
+export const defaultTo = <T>(
+	defaultValue: T,
+	writableStrategy?: QueuingStrategy,
+	readableStrategy?: QueuingStrategy,
+) => {
+	return map(
+		(chunk) => chunk ?? defaultValue,
+		writableStrategy,
+		readableStrategy,
+	);
+};

src/numbers/greaterThan.ts

@@ -1,9 +1,13 @@
 import { filter } from "../filter";
 
 export const greaterThan = (
-    value: number,
-    writableStrategy?: QueuingStrategy,
-    readableStrategy?: QueuingStrategy,
+	value: number,
+	writableStrategy?: QueuingStrategy,
+	readableStrategy?: QueuingStrategy,
 ) => {
-    return filter((chunk: number) => chunk > value, writableStrategy, readableStrategy);
+	return filter(
+		(chunk: number) => chunk > value,
+		writableStrategy,
+		readableStrategy,
+	);
 };

src/numbers/greaterThanEqual.ts

@@ -1,9 +1,13 @@
 import { filter } from "../filter";
 
 export const greaterThanEqual = (
-    value: number,
-    writableStrategy?: QueuingStrategy,
-    readableStrategy?: QueuingStrategy,
+	value: number,
+	writableStrategy?: QueuingStrategy,
+	readableStrategy?: QueuingStrategy,
 ) => {
-    return filter((chunk: number) => chunk >= value, writableStrategy, readableStrategy);
+	return filter(
+		(chunk: number) => chunk >= value,
+		writableStrategy,
+		readableStrategy,
+	);
 };

src/numbers/lessThan.ts

@@ -1,9 +1,13 @@
 import { filter } from "../filter";
 
 export const lessThan = (
-    value: number,
-    writableStrategy?: QueuingStrategy,
-    readableStrategy?: QueuingStrategy,
+	value: number,
+	writableStrategy?: QueuingStrategy,
+	readableStrategy?: QueuingStrategy,
 ) => {
-    return filter((chunk: number) => chunk < value, writableStrategy, readableStrategy);
+	return filter(
+		(chunk: number) => chunk < value,
+		writableStrategy,
+		readableStrategy,
+	);
 };

src/numbers/lessThanEqual.ts

@@ -1,9 +1,13 @@
 import { filter } from "../filter";
 
 export const lessThanEqual = (
-    value: number,
-    writableStrategy?: QueuingStrategy,
-    readableStrategy?: QueuingStrategy,
+	value: number,
+	writableStrategy?: QueuingStrategy,
+	readableStrategy?: QueuingStrategy,
 ) => {
-    return filter((chunk: number) => chunk <= value, writableStrategy, readableStrategy);
+	return filter(
+		(chunk: number) => chunk <= value,
+		writableStrategy,
+		readableStrategy,
+	);
 };

test/defaultTo.test.ts

@@ -0,0 +1,39 @@
+import { describe, it, expect } from "vitest";
+import { defaultTo } from "../src/defaultTo";
+import { fromIterable } from "../src/fromIterable";
+import { pipeline } from "../src/pipeline";
+import { toArray } from "../src/toArray";
+
+describe("defaultTo", () => {
+	it("should work with empty stream", async () => {
+		const destinationArray = [];
+
+		await pipeline(fromIterable([]), defaultTo(1), toArray(destinationArray));
+
+		expect(destinationArray).toEqual([]);
+	});
+
+	it("should work with falsy values", async () => {
+		const destinationArray = [];
+
+		await pipeline(
+			fromIterable([false, 0]),
+			defaultTo(1),
+			toArray(destinationArray),
+		);
+
+		expect(destinationArray).toEqual([false, 0]);
+	});
+
+	it("should work with nullish values", async () => {
+		const destinationArray = [];
+
+		await pipeline(
+			fromIterable([null, undefined]),
+			defaultTo(1),
+			toArray(destinationArray),
+		);
+
+		expect(destinationArray).toEqual([1, 1]);
+	});
+});

test/numbers/greaterThan.test.ts

@@ -6,19 +6,19 @@ import { fromIterable } from "../../src/fromIterable";
 import { greaterThan } from "../../src/numbers/greaterThan";
 
 describe("greaterThan", () => {
-    test("should work with empty list", async () => {
-        const destinationArray = [];
+	test("should work with empty list", async () => {
+		const destinationArray = [];
 
-        await pipeline(fromIterable([]), greaterThan(0), toArray(destinationArray));
+		await pipeline(fromIterable([]), greaterThan(0), toArray(destinationArray));
 
-        expect(destinationArray).toEqual([]);
-    });
+		expect(destinationArray).toEqual([]);
+	});
 
-    test("should correctly filter numbers", async () => {
-        const destinationArray = [];
+	test("should correctly filter numbers", async () => {
+		const destinationArray = [];
 
-        await pipeline(fromRange(1, 3), greaterThan(1), toArray(destinationArray));
+		await pipeline(fromRange(1, 3), greaterThan(1), toArray(destinationArray));
 
-        expect(destinationArray).toEqual([2, 3]);
-    });
+		expect(destinationArray).toEqual([2, 3]);
+	});
 });

test/numbers/greaterThanEqual.test.ts

@@ -6,19 +6,27 @@ import { fromIterable } from "../../src/fromIterable";
 import { greaterThanEqual } from "../../src/numbers/greaterThanEqual";
 
 describe("greaterThanEqual", () => {
-    test("should work with empty list", async () => {
-        const destinationArray = [];
+	test("should work with empty list", async () => {
+		const destinationArray = [];
 
-        await pipeline(fromIterable([]), greaterThanEqual(0), toArray(destinationArray));
+		await pipeline(
+			fromIterable([]),
+			greaterThanEqual(0),
+			toArray(destinationArray),
+		);
 
-        expect(destinationArray).toEqual([]);
-    });
+		expect(destinationArray).toEqual([]);
+	});
 
-    test("should correctly filter numbers", async () => {
-        const destinationArray = [];
+	test("should correctly filter numbers", async () => {
+		const destinationArray = [];
 
-        await pipeline(fromRange(1, 3), greaterThanEqual(1), toArray(destinationArray));
+		await pipeline(
+			fromRange(1, 3),
+			greaterThanEqual(1),
+			toArray(destinationArray),
+		);
 
-        expect(destinationArray).toEqual([1, 2, 3]);
-    });
+		expect(destinationArray).toEqual([1, 2, 3]);
+	});
 });

test/numbers/lessThan.test.ts

@@ -6,19 +6,19 @@ import { fromIterable } from "../../src/fromIterable";
 import { lessThan } from "../../src/numbers/lessThan";
 
 describe("lessThan", () => {
-    test("should work with empty list", async () => {
-        const destinationArray = [];
+	test("should work with empty list", async () => {
+		const destinationArray = [];
 
-        await pipeline(fromIterable([]), lessThan(0), toArray(destinationArray));
+		await pipeline(fromIterable([]), lessThan(0), toArray(destinationArray));
 
-        expect(destinationArray).toEqual([]);
-    });
+		expect(destinationArray).toEqual([]);
+	});
 
-    test("should correctly filter numbers", async () => {
-        const destinationArray = [];
+	test("should correctly filter numbers", async () => {
+		const destinationArray = [];
 
-        await pipeline(fromRange(1, 3), lessThan(3), toArray(destinationArray));
+		await pipeline(fromRange(1, 3), lessThan(3), toArray(destinationArray));
 
-        expect(destinationArray).toEqual([1, 2]);
-    });
+		expect(destinationArray).toEqual([1, 2]);
+	});
 });

test/numbers/lessThanEqual.test.ts

@@ -6,19 +6,27 @@ import { pipeline } from "../../src/pipeline";
 import { toArray } from "../../src/toArray";
 
 describe("lessThanEqual", () => {
-    test("should work with empty list", async () => {
-        const destinationArray = [];
+	test("should work with empty list", async () => {
+		const destinationArray = [];
 
-        await pipeline(fromIterable([]), lessThanEqual(0), toArray(destinationArray));
+		await pipeline(
+			fromIterable([]),
+			lessThanEqual(0),
+			toArray(destinationArray),
+		);
 
-        expect(destinationArray).toEqual([]);
-    });
+		expect(destinationArray).toEqual([]);
+	});
 
-    test("should correctly filter numbers", async () => {
-        const destinationArray = [];
+	test("should correctly filter numbers", async () => {
+		const destinationArray = [];
 
-        await pipeline(fromRange(1, 3), lessThanEqual(3), toArray(destinationArray));
+		await pipeline(
+			fromRange(1, 3),
+			lessThanEqual(3),
+			toArray(destinationArray),
+		);
 
-        expect(destinationArray).toEqual([1, 2, 3]);
-    });
+		expect(destinationArray).toEqual([1, 2, 3]);
+	});
 });