feat!: Switch to streamx & remove obj API (closes #7) (#11)

README.md

@@ -20,7 +20,7 @@ var mkdirpStream = require('fs-mkdirp-stream');
 from
   .obj([{ dirname: '/path/to/my/', path: '/path/to/my/file.js' }])
   .pipe(
-    mkdirpStream.obj(function (obj, callback) {
+    mkdirpStream(function (obj, callback) {
       // callback can take 3 arguments (err, dirname, mode)
       callback(null, obj.dirname);
     })
@@ -37,16 +37,12 @@ from
 
 ### `mkdirpStream(resolver)`
 
-Takes a `resolver` function or string and returns a `through2` stream.
+Takes a `resolver` function or string and returns a `streamx.Transform` stream.
 
 If the `resolver` is a function, it will be called once per chunk with the signature `(chunk, callback)`. The `callback(error, dirpath, mode)` must be called with the `dirpath` to be created as the 2nd parameter or an `error` as the 1st parameter; optionally with a `mode` as the 3rd parameter.
 
 If the `resolver` is a string, it will be created/ensured for each chunk (e.g. if it were deleted between chunks, it would be recreated). When using a string, a custom `mode` can't be used.
 
-### `mkdirpStream.obj(resolver)`
-
-The same as the top-level API but for object streams. See the example to see the benefit of object streams with this module.
-
 ## License
 
 MIT

index.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var through = require('through2');
+var Transform = require('streamx').Transform;
 
 var mkdirp = require('./mkdirp');
 
@@ -12,14 +12,14 @@ function toFunction(dirpath) {
   return stringResolver;
 }
 
-function define(options) {
-  function mkdirpStream(resolver) {
-    // Handle resolver that's just a dirpath
-    if (typeof resolver === 'string') {
-      resolver = toFunction(resolver);
-    }
+function mkdirpStream(resolver) {
+  // Handle resolver that's just a dirpath
+  if (typeof resolver === 'string') {
+    resolver = toFunction(resolver);
+  }
 
-    function makeFileDirs(chunk, enc, callback) {
+  return new Transform({
+    transform: function (chunk, callback) {
       resolver(chunk, onDirpath);
 
       function onDirpath(dirpathErr, dirpath, mode) {
@@ -37,13 +37,8 @@ function define(options) {
 
         callback(null, chunk);
       }
-    }
-
-    return through(options, makeFileDirs);
-  }
-
-  return mkdirpStream;
+    },
+  });
 }
 
-module.exports = define();
-module.exports.obj = define({ objectMode: true, highWaterMark: 16 });
+module.exports = mkdirpStream;

package.json

@@ -24,17 +24,16 @@
   },
   "dependencies": {
     "graceful-fs": "^4.1.11",
-    "through2": "^2.0.3"
+    "streamx": "^2.6.0"
   },
   "devDependencies": {
     "eslint": "^6.8.0",
-    "eslint-config-gulp": "^4.0.0",
-    "expect": "^25.4.0",
-    "jest-mock": "^25.5.0",
-    "mississippi": "^1.3.0",
+    "eslint-config-gulp": "^5.0.0",
+    "expect": "^26.0.1",
+    "jest-mock": "^26.0.1",
     "mocha": "^7.1.2",
     "nyc": "^15.0.1",
-    "rimraf": "^2.6.1"
+    "rimraf": "^3.0.2"
   },
   "nyc": {
     "reporter": [

test/index.js

@@ -2,19 +2,18 @@
 
 var os = require('os');
 var path = require('path');
+var pipeline = require('stream').pipeline;
 
 var fs = require('graceful-fs');
-var miss = require('mississippi');
 var mock = require('jest-mock');
 var expect = require('expect');
 var rimraf = require('rimraf');
+var streamx = require('streamx');
+var Readable = streamx.Readable;
+var Writable = streamx.Writable;
 
 var mkdirpStream = require('../');
 
-var pipe = miss.pipe;
-var from = miss.from;
-var concat = miss.concat;
-
 describe('mkdirpStream', function () {
   var MASK_MODE = parseInt('7777', 8);
   var isWindows = os.platform() === 'win32';
@@ -67,33 +66,34 @@ describe('mkdirpStream', function () {
     });
   });
 
-  it('exports a main function, .obj and .withMode methods', function (done) {
+  it('exports a main function', function (done) {
     expect(typeof mkdirpStream).toEqual('function');
-    expect(typeof mkdirpStream.obj).toEqual('function');
     done();
   });
 
   it('takes a string to create', function (done) {
-    function assert() {
+    function assert(err) {
       expect(statMode(outputDirpath)).toBeDefined();
+      done(err);
     }
 
-    pipe([from(['test']), mkdirpStream(outputDirpath), concat(assert)], done);
+    pipeline(Readable.from(['test']), mkdirpStream(outputDirpath), new Writable(), assert);
   });
 
   it('takes a resolver function that receives chunk', function (done) {
-    var expected = Buffer.from('test');
+    var expected = 'test';
 
     function resolver(chunk, cb) {
-      expect(chunk.equals(expected)).toEqual(true);
+      expect(chunk).toEqual(expected);
       cb(null, outputDirpath);
     }
 
-    function assert() {
+    function assert(err) {
       expect(statMode(outputDirpath)).toBeDefined();
+      done(err);
     }
 
-    pipe([from(['test']), mkdirpStream(resolver), concat(assert)], done);
+    pipeline(Readable.from(['test']), mkdirpStream(resolver), new Writable(), assert);
   });
 
   it('can pass a mode as the 3rd argument to the resolver callback', function (done) {
@@ -104,18 +104,19 @@ describe('mkdirpStream', function () {
 
     var mode = applyUmask('700');
 
-    var expected = Buffer.from('test');
+    var expected = 'test';
 
     function resolver(chunk, cb) {
-      expect(chunk.equals(expected)).toEqual(true);
+      expect(chunk).toEqual(expected);
       cb(null, outputDirpath, mode);
     }
 
-    function assert() {
+    function assert(err) {
       expect(statMode(outputDirpath)).toEqual(mode);
+      done(err);
     }
 
-    pipe([from(['test']), mkdirpStream(resolver), concat(assert)], done);
+    pipeline(Readable.from(['test']), mkdirpStream(resolver), new Writable(), assert);
   });
 
   it('can pass an error as the 1st argument to the resolver callback to error', function (done) {
@@ -133,7 +134,7 @@ describe('mkdirpStream', function () {
       done();
     }
 
-    pipe([from(['test']), mkdirpStream(resolver), concat()], assert);
+    pipeline(Readable.from(['test']), mkdirpStream(resolver), new Writable(), assert);
   });
 
   it('works with objectMode', function (done) {
@@ -143,17 +144,16 @@ describe('mkdirpStream', function () {
       cb(null, chunk.dirname);
     }
 
-    function assert() {
+    function assert(err) {
       expect(statMode(outputDirpath)).toBeDefined();
+      done(err);
     }
 
-    pipe(
-      [
-        from.obj([{ dirname: outputDirpath }]),
-        mkdirpStream.obj(resolver),
-        concat(assert),
-      ],
-      done
+    pipeline(
+      Readable.from([{ dirname: outputDirpath }]),
+      mkdirpStream(resolver),
+      new Writable(),
+      assert
     );
   });
 
@@ -172,6 +172,6 @@ describe('mkdirpStream', function () {
       done();
     }
 
-    pipe([from(['test']), mkdirpStream(outputDirpath), concat()], assert);
+    pipeline(Readable.from(['test']), mkdirpStream(outputDirpath), new Writable(), assert);
   });
 });