Merge pull request #390 from webpack-contrib/faster-stats-json-writer

Replace `bfj` module with custom `stats.json` writer

Author: th0r

CHANGELOG.md

@@ -14,6 +14,9 @@ _Note: Gaps between patch versions are faulty, broken or test releases._
 
 <!-- Add changelog entries for new changes under this section -->
 
+ * **Improvement**
+   * Significantly speed up generation of `stats.json` file (see `generateStatsFile` option).
+
 ## 4.0.0
 
  * **Breaking change**

package-lock.json

@@ -36,7 +36,6 @@
   "dependencies": {
     "acorn": "^8.0.4",
     "acorn-walk": "^8.0.0",
-    "bfj": "^7.0.2",
     "chalk": "^4.1.0",
     "commander": "^6.2.0",
     "ejs": "^3.1.5",
@@ -73,6 +72,7 @@
     "eslint-config-th0r-react": "2.0.1",
     "eslint-plugin-react": "7.21.5",
     "exports-loader": "1.1.1",
+    "globby": "11.0.1",
     "gulp": "4.0.2",
     "gulp-babel": "8.0.0",
     "mobx": "5.15.7",

package.json

@@ -1,11 +1,11 @@
-const bfj = require('bfj');
 const path = require('path');
 const mkdir = require('mkdirp');
 const {bold} = require('chalk');
 
 const Logger = require('./Logger');
 const viewer = require('./viewer');
 const utils = require('./utils');
+const {writeStats} = require('./statsUtils');
 
 class BundleAnalyzerPlugin {
   constructor(opts = {}) {
@@ -83,14 +83,7 @@ class BundleAnalyzerPlugin {
     mkdir.sync(path.dirname(statsFilepath));
 
     try {
-      await bfj.write(statsFilepath, stats, {
-        space: 2,
-        promises: 'ignore',
-        buffers: 'ignore',
-        maps: 'ignore',
-        iterables: 'ignore',
-        circular: 'ignore'
-      });
+      await writeStats(stats, statsFilepath);
 
       this.logger.info(
         `${bold('Webpack Bundle Analyzer')} saved stats file to ${bold(statsFilepath)}`

src/BundleAnalyzerPlugin.js

@@ -0,0 +1,82 @@
+const {createWriteStream} = require('fs');
+const {Readable} = require('stream');
+
+class StatsSerializeStream extends Readable {
+  constructor(stats) {
+    super();
+    this._indentLevel = 0;
+    this._stringifier = this._stringify(stats);
+  }
+
+  get _indent() {
+    return '  '.repeat(this._indentLevel);
+  }
+
+  _read() {
+    let readMore = true;
+
+    while (readMore) {
+      const {value, done} = this._stringifier.next();
+
+      if (done) {
+        this.push(null);
+        readMore = false;
+      } else {
+        readMore = this.push(value);
+      }
+    }
+  }
+
+  * _stringify(obj) {
+    if (typeof obj === 'string' || typeof obj === 'number' || typeof obj === 'boolean' || obj === null) {
+      yield JSON.stringify(obj);
+    } else if (Array.isArray(obj)) {
+      yield '[';
+      this._indentLevel++;
+
+      let isFirst = true;
+      for (let item of obj) {
+        if (item === undefined) {
+          item = null;
+        }
+
+        yield `${isFirst ? '' : ','}\n${this._indent}`;
+        yield* this._stringify(item);
+        isFirst = false;
+      }
+
+      this._indentLevel--;
+      yield obj.length ? `\n${this._indent}]` : ']';
+    } else {
+      yield '{';
+      this._indentLevel++;
+
+      let isFirst = true;
+      const entries = Object.entries(obj);
+      for (const [itemKey, itemValue] of entries) {
+        if (itemValue === undefined) {
+          continue;
+        }
+
+        yield `${isFirst ? '' : ','}\n${this._indent}${JSON.stringify(itemKey)}: `;
+        yield* this._stringify(itemValue);
+        isFirst = false;
+      }
+
+      this._indentLevel--;
+      yield entries.length ? `\n${this._indent}}` : '}';
+    }
+  }
+}
+
+exports.StatsSerializeStream = StatsSerializeStream;
+exports.writeStats = writeStats;
+
+async function writeStats(stats, filepath) {
+  return new Promise((resolve, reject) => {
+    new StatsSerializeStream(stats)
+      .on('end', resolve)
+      .on('error', reject)
+      .pipe(createWriteStream(filepath));
+  });
+}

src/statsUtils.js

@@ -0,0 +1,76 @@
+const path = require('path');
+const {readFileSync} = require('fs');
+const globby = require('globby');
+
+const {StatsSerializeStream} = require('../lib/statsUtils');
+
+describe('StatsSerializeStream', () => {
+  it('should properly stringify primitives', function () {
+    expectProperJson(0);
+    expectProperJson(1);
+    expectProperJson(-1);
+    expectProperJson(42.42);
+    expectProperJson(-42.42);
+    expectProperJson(false);
+    expectProperJson(true);
+    expectProperJson(null);
+    expectProperJson(null);
+    expectProperJson('');
+    expectProperJson('"');
+    expectProperJson('foo bar');
+    expectProperJson('"foo bar"');
+    expectProperJson('Вива Лас-Вегас!');
+  });
+
+  it('should properly stringify simple arrays', function () {
+    expectProperJson([]);
+    expectProperJson([1, undefined, 2]);
+    // eslint-disable-next-line
+    expectProperJson([1, , 2]);
+    expectProperJson([false, 'f\'o"o', -1, 42.42]);
+  });
+
+  it('should properly stringify objects', function () {
+    expectProperJson({});
+    expectProperJson({a: 1, 'foo-bar': null, undef: undefined, '"Гусь!"': true});
+  });
+
+  it('should properly stringify complex structures', function () {
+    expectProperJson({
+      foo: [],
+      bar: {
+        baz: [
+          1,
+          {a: 1, b: ['foo', 'bar'], c: []},
+          'foo',
+          {a: 1, b: undefined, c: [{d: true}]},
+          null,
+          undefined
+        ]
+      }
+    });
+  });
+
+  globby.sync('stats/**/*.json', {cwd: __dirname}).forEach(filepath => {
+    it(`should properly stringify JSON from "${filepath}"`, function () {
+      const content = readFileSync(path.resolve(__dirname, filepath), 'utf8');
+      const json = JSON.parse(content);
+      expectProperJson(json);
+    });
+  });
+});
+
+async function expectProperJson(json) {
+  expect(await stringify(json)).to.equal(JSON.stringify(json, null, 2));
+}
+
+async function stringify(json) {
+  return new Promise((resolve, reject) => {
+    let result = '';
+
+    new StatsSerializeStream(json)
+      .on('data', chunk => result += chunk)
+      .on('end', () => resolve(result))
+      .on('error', reject);
+  });
+}