Reflect treeshaking, only in plugin currently

Author: doesdev

index.js

@@ -18,11 +18,19 @@ const analyze = (bundle, opts = {}, format = false) => {
   let { root, limit, filter } = opts;
   let deps = {};
   let bundleSize = 0;
+  let bundleModules = bundle.modules;
 
   return new Promise((resolve, reject) => {
-    let modules = bundle.modules.map((m, i) => {
+    if (bundleModules && !Array.isArray(bundleModules)) {
+      bundleModules = Object.entries(bundleModules).map(([id, obj]) => {
+        let { originalLength, renderedLength } = obj;
+        return {id, dependencies: [], originalLength, renderedLength}
+      });
+    }
+
+    let modules = bundleModules.map((m, i) => {
       let id = m.id.replace(root, '');
-      let size = Buffer.byteLength(m.code, 'utf8') || 0;
+      let size = m.renderedLength || Buffer.byteLength(m.code, 'utf8') || 0;
       bundleSize += size;
 
       if (Array.isArray(filter) && !filter.some((f) => id.match(f))) return null
@@ -68,12 +76,20 @@ const analyze = (bundle, opts = {}, format = false) => {
 const formatted = (bndl, opts) => analyze(bndl, opts, true);
 
 const plugin = (opts = {}) => {
-  let log = opts.writeTo || (opts.stdout ? console.log : console.error);
+  let cb = opts.writeTo || (opts.stdout ? console.log : console.error);
+  if (opts.onAnalysis) cb = opts.onAnalysis;
+  let written;
+
+  let runAnalysis = (outputOptions, bundle, isWrite) => {
+    if (written) return
+    if (outputOptions.bundle) bundle = outputOptions.bundle;
+    written = true;
+    return analyze(bundle, opts, !opts.onAnalysis).then(cb)
+  };
   return {
     name: 'rollup-analyzer-plugin',
-    ongenerate: ({bundle}) => {
-      return formatted(bundle, opts).then(log)
-    }
+    generateBundle: runAnalysis,
+    ongenerate: runAnalysis
   }
 };
 

module.js

@@ -16,11 +16,19 @@ export const analyze = (bundle, opts = {}, format = false) => {
   let { root, limit, filter } = opts
   let deps = {}
   let bundleSize = 0
+  let bundleModules = bundle.modules
 
   return new Promise((resolve, reject) => {
-    let modules = bundle.modules.map((m, i) => {
+    if (bundleModules && !Array.isArray(bundleModules)) {
+      bundleModules = Object.entries(bundleModules).map(([id, obj]) => {
+        let { originalLength, renderedLength } = obj
+        return {id, dependencies: [], originalLength, renderedLength}
+      })
+    }
+
+    let modules = bundleModules.map((m, i) => {
       let id = m.id.replace(root, '')
-      let size = Buffer.byteLength(m.code, 'utf8') || 0
+      let size = m.renderedLength || Buffer.byteLength(m.code, 'utf8') || 0
       bundleSize += size
 
       if (Array.isArray(filter) && !filter.some((f) => id.match(f))) return null
@@ -66,11 +74,19 @@ export const analyze = (bundle, opts = {}, format = false) => {
 export const formatted = (bndl, opts) => analyze(bndl, opts, true)
 
 export const plugin = (opts = {}) => {
-  let log = opts.writeTo || (opts.stdout ? console.log : console.error)
+  let cb = opts.writeTo || (opts.stdout ? console.log : console.error)
+  if (opts.onAnalysis) cb = opts.onAnalysis
+  let written
+
+  let runAnalysis = (outputOptions, bundle, isWrite) => {
+    if (written) return
+    if (outputOptions.bundle) bundle = outputOptions.bundle
+    written = true
+    return analyze(bundle, opts, !opts.onAnalysis).then(cb)
+  }
   return {
     name: 'rollup-analyzer-plugin',
-    ongenerate: ({bundle}) => {
-      return formatted(bundle, opts).then(log)
-    }
+    generateBundle: runAnalysis,
+    ongenerate: runAnalysis
   }
 }

test/index.js

@@ -29,14 +29,14 @@ Rollup File Analysis
 const rollers = [
   {rollup: rollupLatest, version: 'latest', opts: baseOpts},
   {rollup: rollup60, version: '0.60.x', opts: baseOpts},
-  {rollup: rollup55, version: '0.55.x', opts: baseOpts},
-  {rollup: rollup50, version: '0.50.x', opts: baseOpts},
-  {rollup: rollup45, version: '0.45.x', opts: oldOpts},
-  {rollup: rollup40, version: '0.40.x', opts: oldOpts}
+  {rollup: rollup55, version: '0.55.x', opts: baseOpts, noTreeshake: true},
+  {rollup: rollup50, version: '0.50.x', opts: baseOpts, noTreeshake: true},
+  {rollup: rollup45, version: '0.45.x', opts: oldOpts, noTreeshake: true},
+  {rollup: rollup40, version: '0.40.x', opts: oldOpts, noTreeshake: true}
 ]
 
 // main
-rollers.forEach(({rollup, version, opts}) => {
+rollers.forEach(({rollup, version, opts, noTreeshake}) => {
   test(`${version}: formatted returns string`, async (assert) => {
     let bundle = await rollup(opts)
     let results = await formatted(bundle)
@@ -96,9 +96,7 @@ rollers.forEach(({rollup, version, opts}) => {
     assert.is(typeof results, 'string')
   })
 
-  let shouldFailPlugin = {latest: true, '0.60.x': true}
-  let pluginTest = shouldFailPlugin[version] ? test.failing : test
-  pluginTest(`${version}: plugin writes expected results`, async (assert) => {
+  test(`${version}: plugin writes expected results`, async (assert) => {
     let results
     let writeTo = (r) => { results = r }
     let rollOpts = Object.assign({plugins: [plugin({writeTo})]}, opts)
@@ -107,10 +105,15 @@ rollers.forEach(({rollup, version, opts}) => {
     assert.is(results.substr(0, expectHeader.length), expectHeader)
   })
 
-  test.failing(`${version}: tree shaking is accounted for`, async (assert) => {
-    let bundle = await rollup(opts)
-    let results = await analyze(bundle)
-    let imported = results.find((r) => r.id.match('importme'))
-    assert.is(imported.size, 4)
-  })
+  if (!noTreeshake) {
+    test(`${version}: tree shaking is accounted for`, async (assert) => {
+      let results
+      let onAnalysis = (r) => { results = r }
+      let rollOpts = Object.assign({plugins: [plugin({onAnalysis})]}, opts)
+      let bundle = await rollup(rollOpts)
+      await bundle.generate({format: 'cjs'})
+      let imported = results.find((r) => r.id.indexOf('import-a') !== -1)
+      assert.is(imported.size, 27)
+    })
+  }
 })