DefaultOptions implemented as module factory

tests/accumulator.spec.ts

@@ -1,9 +1,10 @@
 import test from "ava";
 import { expect } from "chai";
 import { Readable } from "stream";
-import { accumulator, accumulatorBy } from "../src";
+import mhysa from "../src";
 import { FlushStrategy } from "../src/functions/accumulator";
 import { performance } from "perf_hooks";
+const { accumulator, accumulatorBy } = mhysa({ objectMode: true });
 
 test.cb("accumulator() rolling", t => {
     t.plan(3);

tests/batch.spec.ts

@@ -1,7 +1,8 @@
 import { Readable } from "stream";
 import test from "ava";
 import { expect } from "chai";
-import { batch } from "../src";
+import mhysa from "../src";
+const { batch } = mhysa({ objectMode: true });
 
 test.cb("batch() batches chunks together", t => {
     t.plan(3);
@@ -31,7 +32,9 @@ test.cb("batch() yields a batch after the timeout", t => {
     t.plan(3);
     const source = new Readable({
         objectMode: true,
-        read(size: number) {},
+        read(size: number) {
+            return;
+        },
     });
     const expectedElements = [["a", "b"], ["c"], ["d"]];
     let i = 0;

tests/child.spec.ts

@@ -2,7 +2,8 @@ import * as cp from "child_process";
 import { Readable } from "stream";
 import test from "ava";
 import { expect } from "chai";
-import { child } from "../src";
+import mhysa from "../src";
+const { child } = mhysa();
 
 test.cb(
     "child() allows easily writing to child process stdin and reading from its stdout",

tests/collect.spec.ts

@@ -1,7 +1,8 @@
 import { Readable } from "stream";
 import test from "ava";
 import { expect } from "chai";
-import { collect } from "../src";
+import mhysa from "../src";
+const { collect } = mhysa();
 
 test.cb(
     "collect() collects streamed elements into an array (object, flowing mode)",

tests/compose.spec.ts

@@ -1,8 +1,9 @@
 const test = require("ava");
 const { expect } = require("chai");
-const { compose, map } = require("../src");
 const { sleep } = require("../src/helpers");
+import mhysa from "../src";
 import { performance } from "perf_hooks";
+const { compose, map } = mhysa({ objectMode: true });
 
 test.cb("compose() chains two streams together in the correct order", t => {
     t.plan(3);
@@ -211,7 +212,7 @@ test("compose() should emit drain event ~rate * highWaterMark ms for every write
             expect(composed._writableState.length).to.be.equal(0);
             expect(performance.now() - start).to.be.closeTo(
                 _rate * highWaterMark,
-                20,
+                40,
             );
         });
 
@@ -286,7 +287,7 @@ test.cb(
             expect(composed._writableState.length).to.be.equal(0);
             expect(performance.now() - start).to.be.closeTo(
                 _rate * input.length,
-                25,
+                50,
             );
             t.pass();
         });

tests/concat.spec.ts

@@ -1,7 +1,8 @@
 import { Readable } from "stream";
 import test from "ava";
 import { expect } from "chai";
-import { concat, collect } from "../src";
+import mhysa from "../src";
+const { concat, collect } = mhysa();
 
 test.cb(
     "concat() concatenates multiple readable streams (object, flowing mode)",

tests/defaultOptions.spec.ts

@@ -0,0 +1,21 @@
+import { Readable } from "stream";
+import test from "ava";
+import mhysa from "../src";
+
+const withDefaultOptions = mhysa({ objectMode: true });
+const withoutOptions = mhysa();
+
+test("Mhysa instances can have default options", t => {
+    let batch = withDefaultOptions.batch();
+    t.true(batch._readableState.objectMode);
+    t.true(batch._writableState.objectMode);
+    batch = withDefaultOptions.batch(3);
+    t.true(batch._readableState.objectMode);
+    t.true(batch._writableState.objectMode);
+    batch = withDefaultOptions.batch(3, 1);
+    t.true(batch._readableState.objectMode);
+    t.true(batch._writableState.objectMode);
+    batch = withDefaultOptions.batch(3, 1, { objectMode: false });
+    t.false(batch._readableState.objectMode);
+    t.false(batch._writableState.objectMode);
+});

tests/demux.spec.ts

@@ -1,10 +1,11 @@
 import test from "ava";
 import { expect } from "chai";
-const { demux, map } = require("../src");
+import mhysa from "../src";
 import { Writable } from "stream";
 const sinon = require("sinon");
 const { sleep } = require("../src/helpers");
 import { performance } from "perf_hooks";
+const { demux, map } = mhysa();
 
 interface Test {
     key: string;

tests/duplex.spec.ts

@@ -2,7 +2,8 @@ import * as cp from "child_process";
 import { Readable } from "stream";
 import test from "ava";
 import { expect } from "chai";
-import { duplex } from "../src";
+import mhysa from "../src";
+const { duplex } = mhysa();
 
 test.cb(
     "duplex() combines a writable and readable stream into a ReadWrite stream",

tests/filter.spec.ts

@@ -1,7 +1,8 @@
 import test from "ava";
 import { expect } from "chai";
 import { Readable } from "stream";
-import { filter } from "../src";
+import mhysa from "../src";
+const { filter } = mhysa();
 
 test.cb("filter() filters elements synchronously", t => {
     t.plan(2);

tests/flatMap.spec.ts

@@ -1,7 +1,8 @@
 import { Readable } from "stream";
 import test from "ava";
 import { expect } from "chai";
-import { flatMap } from "../src";
+import mhysa from "../src";
+const { flatMap } = mhysa({ objectMode: true });
 
 test.cb("flatMap() maps elements synchronously", t => {
     t.plan(6);

tests/fromArray.spec.ts

@@ -1,6 +1,7 @@
 import test from "ava";
 import { expect } from "chai";
-import { fromArray } from "../src";
+import mhysa from "../src";
+const { fromArray } = mhysa();
 
 test.cb("fromArray() streams array elements in flowing mode", t => {
     t.plan(3);

tests/join.spec.ts

@@ -1,7 +1,8 @@
 import { Readable } from "stream";
 import test from "ava";
 import { expect } from "chai";
-import { join } from "../src";
+import mhysa from "../src";
+const { join } = mhysa();
 
 test.cb("join() joins chunks using the specified separator", t => {
     t.plan(9);

tests/last.spec.ts

@@ -1,7 +1,8 @@
 import { Readable } from "stream";
 import test from "ava";
 import { expect } from "chai";
-import { last } from "../src";
+import mhysa from "../src";
+const { last } = mhysa();
 
 test("last() resolves to the last chunk streamed by the given readable stream", async t => {
     const source = new Readable({ objectMode: true });

tests/map.spec.ts

@@ -1,12 +1,15 @@
 import { Readable } from "stream";
 import test from "ava";
 import { expect } from "chai";
-import { map } from "../src";
+import mhysa from "../src";
+const { map } = mhysa();
 
 test.cb("map() maps elements synchronously", t => {
     t.plan(3);
     const source = new Readable({ objectMode: true });
-    const mapStream = map((element: string) => element.toUpperCase());
+    const mapStream = map((element: string) => element.toUpperCase(), {
+        objectMode: true,
+    });
     const expectedElements = ["A", "B", "C"];
     let i = 0;
     source
@@ -28,10 +31,13 @@ test.cb("map() maps elements synchronously", t => {
 test.cb("map() maps elements asynchronously", t => {
     t.plan(3);
     const source = new Readable({ objectMode: true });
-    const mapStream = map(async (element: string) => {
-        await Promise.resolve();
-        return element.toUpperCase();
-    });
+    const mapStream = map(
+        async (element: string) => {
+            await Promise.resolve();
+            return element.toUpperCase();
+        },
+        { objectMode: true },
+    );
     const expectedElements = ["A", "B", "C"];
     let i = 0;
     source

tests/merge.spec.ts

@@ -1,7 +1,8 @@
 import { Readable } from "stream";
 import test from "ava";
 import { expect } from "chai";
-import { merge } from "../src";
+import mhysa from "../src";
+const { merge } = mhysa();
 
 test.cb(
     "merge() merges multiple readable streams in chunk arrival order",

tests/parallelMap.spec.ts

@@ -2,8 +2,9 @@ import { Readable } from "stream";
 import { performance } from "perf_hooks";
 import test from "ava";
 import { expect } from "chai";
-import { parallelMap } from "../src";
+import mhysa from "../src";
 import { sleep } from "../src/helpers";
+const { parallelMap } = mhysa({ objectMode: true });
 
 test.cb("parallelMap() parallel mapping", t => {
     t.plan(6);

tests/parse.spec.ts

@@ -1,7 +1,8 @@
 import { Readable } from "stream";
 import test from "ava";
 import { expect } from "chai";
-import { parse } from "../src";
+import mhysa from "../src";
+const { parse } = mhysa();
 
 test.cb("parse() parses the streamed elements as JSON", t => {
     t.plan(3);

tests/rate.spec.ts

@@ -2,7 +2,8 @@ import { Readable } from "stream";
 import { performance } from "perf_hooks";
 import test from "ava";
 import { expect } from "chai";
-import { rate } from "../src";
+import mhysa from "../src";
+const { rate } = mhysa({ objectMode: true });
 
 test.cb("rate() sends data at a rate of 150", t => {
     t.plan(5);

tests/reduce.spec.ts

@@ -1,7 +1,8 @@
 import { Readable } from "stream";
 import test from "ava";
 import { expect } from "chai";
-import { reduce } from "../src";
+import mhysa from "../src";
+const { reduce } = mhysa({ objectMode: true });
 
 test.cb("reduce() reduces elements synchronously", t => {
     t.plan(1);

tests/replace.spec.ts

@@ -1,7 +1,8 @@
 import { Readable } from "stream";
 import test from "ava";
 import { expect } from "chai";
-import { replace } from "../src";
+import mhysa from "../src";
+const { replace } = mhysa();
 
 test.cb(
     "replace() replaces occurrences of the given string in the streamed elements with the specified " +

tests/split.spec.ts

@@ -1,7 +1,8 @@
 import { Readable } from "stream";
 import test from "ava";
 import { expect } from "chai";
-import { split } from "../src";
+import mhysa from "../src";
+const { split } = mhysa();
 
 test.cb("split() splits chunks using the default separator (\\n)", t => {
     t.plan(5);

tests/stringify.spec.ts

@@ -1,7 +1,8 @@
 import { Readable } from "stream";
 import test from "ava";
 import { expect } from "chai";
-import { stringify } from "../src";
+import mhysa from "../src";
+const { stringify } = mhysa();
 
 test.cb("stringify() stringifies the streamed elements as JSON", t => {
     t.plan(4);

tests/unbatch.spec.ts

@@ -1,7 +1,8 @@
 import { Readable } from "stream";
 import test from "ava";
 import { expect } from "chai";
-import { unbatch, batch } from "../src";
+import mhysa from "../src";
+const { unbatch, batch } = mhysa({ objectMode: true });
 
 test.cb("unbatch() unbatches", t => {
     t.plan(3);
@@ -9,7 +10,7 @@ test.cb("unbatch() unbatches", t => {
     const expectedElements = ["a", "b", "c"];
     let i = 0;
     source
-        .pipe(batch(3))
+        .pipe(batch(3, undefined, { objectMode: true }))
         .pipe(unbatch())
         .on("data", (element: string) => {
             expect(element).to.equal(expectedElements[i]);