Remove support for rollup < 1.0.0, support 1.0.0

Author: doesdev

index.js

@@ -42,13 +42,13 @@ const reporter = (analysis, opts) => {
         formatted += `${tab}-${buf}${d.replace(root, '')}\n`;
       });
     }
-    if (showExports && m.usedExports && m.unusedExports) {
-      formatted += `used exports:   ${buf}${m.usedExports.length}\n`;
-      m.usedExports.forEach((e) => {
+    if (showExports && m.renderedExports && m.removedExports) {
+      formatted += `used exports:   ${buf}${m.renderedExports.length}\n`;
+      m.renderedExports.forEach((e) => {
         formatted += `${tab}-${buf}${e}\n`;
       });
-      formatted += `unused exports: ${buf}${m.unusedExports.length}\n`;
-      m.unusedExports.forEach((e) => {
+      formatted += `unused exports: ${buf}${m.removedExports.length}\n`;
+      m.removedExports.forEach((e) => {
         formatted += `${tab}-${buf}${e}\n`;
       });
     }
@@ -65,7 +65,7 @@ const analyzer = (bundle, opts = {}) => {
   let deps = {};
   let bundleSize = 0;
   let bundleOrigSize = 0;
-  let bundleModules = bundle.modules || [];
+  let bundleModules = bundle.modules || (bundle.cache || {}).modules || [];
   let moduleCount = bundleModules.length;
 
   let modules = bundleModules.map((m, i) => {
@@ -74,8 +74,8 @@ const analyzer = (bundle, opts = {}) => {
       originalLength: origSize,
       renderedLength,
       code,
-      usedExports,
-      unusedExports
+      renderedExports,
+      removedExports
     } = m;
     id = id.replace(root, '');
     if (transformModuleId) id = transformModuleId(id);
@@ -94,7 +94,7 @@ const analyzer = (bundle, opts = {}) => {
       deps[d].push(id);
     });
 
-    return { id, size, origSize, usedExports, unusedExports }
+    return { id, size, origSize, renderedExports, removedExports }
   }).filter((m) => m);
 
   modules.sort((a, b) => b.size - a.size);
@@ -127,42 +127,32 @@ const formatted = (bundle, opts) => new Promise((resolve, reject) => {
 
 const plugin = (opts = {}) => {
   let writeTo = opts.writeTo || (opts.stdout ? console.log : console.error);
-  let depMap = {};
 
   let onAnalysis = (analysis) => {
     if (typeof opts.onAnalysis === 'function') opts.onAnalysis(analysis);
     if (!opts.skipFormatted) writeTo(reporter(analysis, opts));
   };
 
-  let runAnalysis = (out, bundle, isWrite) => new Promise((resolve, reject) => {
-    resolve();
-    if (out.bundle) bundle = out.bundle;
-    let modules = bundle.modules;
-
-    if (Array.isArray(modules)) {
-      return analyze({ modules }, opts).then(onAnalysis).catch(console.error)
-    }
-
-    modules = Object.keys(modules).map((k) => {
-      let module = Object.assign(modules[k], depMap[k] || {});
-      module.usedExports = module.renderedExports;
-      module.unusedExports = module.removedExports;
-      return module
-    });
-    return analyze({ modules }, opts).then(onAnalysis).catch(console.error)
-  });
-
   return {
     name: 'rollup-plugin-analyzer',
-    transformChunk: (_a, _b, chunk) => new Promise((resolve, reject) => {
-      resolve(null);
-      if (!chunk || !chunk.orderedModules) return
-      chunk.orderedModules.forEach(({ id, dependencies }) => {
-        depMap[id] = { id, dependencies: dependencies.map((d) => d.id) };
-      });
-    }),
-    generateBundle: runAnalysis,
-    ongenerate: runAnalysis
+    generateBundle: function (outOpts, bundle, isWrite) {
+      const ctx = this || {};
+      const getDeps = (id) => {
+        return ctx.getModuleInfo ? ctx.getModuleInfo(id).importedIds : []
+      };
+
+      return new Promise((resolve, reject) => {
+        resolve();
+        const modules = [];
+        Object.entries(bundle).forEach(([outId, { modules: bundleMods }]) => {
+          Object.entries(bundleMods).forEach(([id, moduleInfo]) => {
+            const dependencies = getDeps(id);
+            modules.push(Object.assign({}, moduleInfo, { id, dependencies }));
+          });
+        });
+        return analyze({ modules }, opts).then(onAnalysis).catch(console.error)
+      })
+    }
   }
 };
 

module.js

@@ -40,13 +40,13 @@ export const reporter = (analysis, opts) => {
         formatted += `${tab}-${buf}${d.replace(root, '')}\n`
       })
     }
-    if (showExports && m.usedExports && m.unusedExports) {
-      formatted += `used exports:   ${buf}${m.usedExports.length}\n`
-      m.usedExports.forEach((e) => {
+    if (showExports && m.renderedExports && m.removedExports) {
+      formatted += `used exports:   ${buf}${m.renderedExports.length}\n`
+      m.renderedExports.forEach((e) => {
         formatted += `${tab}-${buf}${e}\n`
       })
-      formatted += `unused exports: ${buf}${m.unusedExports.length}\n`
-      m.unusedExports.forEach((e) => {
+      formatted += `unused exports: ${buf}${m.removedExports.length}\n`
+      m.removedExports.forEach((e) => {
         formatted += `${tab}-${buf}${e}\n`
       })
     }
@@ -63,7 +63,7 @@ const analyzer = (bundle, opts = {}) => {
   let deps = {}
   let bundleSize = 0
   let bundleOrigSize = 0
-  let bundleModules = bundle.modules || []
+  let bundleModules = bundle.modules || (bundle.cache || {}).modules || []
   let moduleCount = bundleModules.length
 
   let modules = bundleModules.map((m, i) => {
@@ -72,8 +72,8 @@ const analyzer = (bundle, opts = {}) => {
       originalLength: origSize,
       renderedLength,
       code,
-      usedExports,
-      unusedExports
+      renderedExports,
+      removedExports
     } = m
     id = id.replace(root, '')
     if (transformModuleId) id = transformModuleId(id)
@@ -92,7 +92,7 @@ const analyzer = (bundle, opts = {}) => {
       deps[d].push(id)
     })
 
-    return { id, size, origSize, usedExports, unusedExports }
+    return { id, size, origSize, renderedExports, removedExports }
   }).filter((m) => m)
 
   modules.sort((a, b) => b.size - a.size)
@@ -132,34 +132,26 @@ export const plugin = (opts = {}) => {
     if (!opts.skipFormatted) writeTo(reporter(analysis, opts))
   }
 
-  let runAnalysis = (out, bundle, isWrite) => new Promise((resolve, reject) => {
-    resolve()
-    if (out.bundle) bundle = out.bundle
-    let modules = bundle.modules
-
-    if (Array.isArray(modules)) {
-      return analyze({ modules }, opts).then(onAnalysis).catch(console.error)
-    }
-
-    modules = Object.keys(modules).map((k) => {
-      let module = Object.assign(modules[k], depMap[k] || {})
-      module.usedExports = module.renderedExports
-      module.unusedExports = module.removedExports
-      return module
-    })
-    return analyze({ modules }, opts).then(onAnalysis).catch(console.error)
-  })
-
   return {
     name: 'rollup-plugin-analyzer',
-    transformChunk: (_a, _b, chunk) => new Promise((resolve, reject) => {
-      resolve(null)
-      if (!chunk || !chunk.orderedModules) return
-      chunk.orderedModules.forEach(({ id, dependencies }) => {
-        depMap[id] = { id, dependencies: dependencies.map((d) => d.id) }
+    generateBundle: function (outOpts, bundle, isWrite) {
+      const ctx = this || {}
+      const getDeps = (id) => {
+        return ctx.getModuleInfo ? ctx.getModuleInfo(id).importedIds : []
+      }
+
+      return new Promise((resolve, reject) => {
+        resolve()
+        const modules = []
+        Object.entries(bundle).forEach(([outId, { modules: bundleMods }]) => {
+          Object.entries(bundleMods).forEach(([id, moduleInfo]) => {
+            depMap[id] = moduleInfo
+            const dependencies = getDeps(id)
+            modules.push(Object.assign({}, moduleInfo, { id, dependencies }))
+          })
+        })
+        return analyze({ modules }, opts).then(onAnalysis).catch(console.error)
       })
-    }),
-    generateBundle: runAnalysis,
-    ongenerate: runAnalysis
+    }
   }
 }

package.json

@@ -9,7 +9,7 @@
     "module.js"
   ],
   "scripts": {
-    "test": "rollup -c && ava --verbose",
+    "test": "rollup -c && ava --verbose --failFast --serial",
     "precommit": "rollup -c && ava && git add index.js",
     "changelog": "auto-changelog -u -l 50 && git add CHANGELOG.md"
   },
@@ -39,14 +39,11 @@
   },
   "homepage": "https://github.com/doesdev/rollup-plugin-analyzer#readme",
   "devDependencies": {
-    "ava": "^0.25.0",
-    "husky": "^0.14.3",
-    "rollup": "latest",
-    "rollup40": "npm:rollup@0.40.x",
-    "rollup45": "npm:rollup@0.45.x",
-    "rollup50": "npm:rollup@0.50.x",
-    "rollup55": "npm:rollup@0.55.x",
-    "rollup60": "npm:rollup@0.60.x"
+    "ava": "^1.0.1",
+    "husky": "^1.3.1",
+    "rollup": "npm:rollup@latest",
+    "rollup60": "npm:rollup@0.60.x",
+    "rollup100": "npm:rollup@1.0.x"
   },
   "dependencies": {}
 }

test/test.js

@@ -4,21 +4,13 @@ import test from 'ava'
 import { analyze, formatted, plugin } from './../index'
 import { resolve as resolvePath, join, basename } from 'path'
 import { rollup as rollupLatest } from 'rollup'
-import { rollup as rollup60 } from 'rollup60'
-import { rollup as rollup55 } from 'rollup55'
-import { rollup as rollup50 } from 'rollup50'
-import { rollup as rollup45 } from 'rollup45'
-import { rollup as rollup40 } from 'rollup40'
+import { rollup as rollup100 } from 'rollup100'
 const skipFormatted = true
 const fixtures = resolvePath(__dirname, 'fixtures')
 const baseOpts = {
   input: join(fixtures, 'bundle-a.js'),
   output: { format: 'cjs' }
 }
-const oldOpts = {
-  entry: join(fixtures, 'bundle-a.js'),
-  format: 'cjs'
-}
 const multiInputOpts = {
   input: [join(fixtures, 'bundle-a.js'), join(fixtures, 'bundle-b.js')],
   output: { format: 'cjs', dir: join(fixtures, 'multi') }
@@ -33,11 +25,7 @@ const headerLength = expectHeader.length
 // test against many versions of rollup
 const rollers = [
   { rollup: rollupLatest, version: 'latest', opts: baseOpts },
-  { rollup: rollup60, version: '0.60.x', opts: baseOpts },
-  { 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 }
+  { rollup: rollup100, version: '1.0.x', opts: baseOpts }
 ]
 
 // main
@@ -142,32 +130,30 @@ rollers.forEach(({ rollup, version, opts, noTreeshake }) => {
     assert.is(results.substr(0, expectHeader.length), expectHeader)
   })
 
-  if (!noTreeshake) {
-    test(`${version}: tree shaking is accounted for`, async (assert) => {
-      let results
-      let onAnalysis = (r) => { results = r.modules }
-      let plugins = [plugin({ onAnalysis, skipFormatted })]
-      let rollOpts = Object.assign({}, opts, { plugins })
-      let bundle = await rollup(rollOpts)
-      let output = { file: join(fixtures, 'output.js'), format: 'cjs' }
-      await bundle.write(output)
-      let imported = results.find((r) => r.id.indexOf('import-a') !== -1)
-      let expectSize = 27
-      assert.true(Math.abs(imported.size - expectSize) < 5)
-    })
+  test(`${version}: tree shaking is accounted for`, async (assert) => {
+    let results
+    let onAnalysis = (r) => { results = r.modules }
+    let plugins = [plugin({ onAnalysis, skipFormatted })]
+    let rollOpts = Object.assign({}, opts, { plugins })
+    let bundle = await rollup(rollOpts)
+    let output = { file: join(fixtures, 'output.js'), format: 'cjs' }
+    await bundle.write(output)
+    let imported = results.find((r) => r.id.indexOf('import-a') !== -1)
+    let expectSize = 27
+    assert.true(Math.abs(imported.size - expectSize) < 5)
+  })
 
-    test(`${version}: treeshaken bundle filters with callback`, async (assert) => {
-      let results
-      let filter = (m) => m.size > 2000
-      let onAnalysis = (r) => { results = r.modules }
-      let plugins = [plugin({ onAnalysis, filter, skipFormatted })]
-      let rollOpts = Object.assign({}, opts, { plugins })
-      let bundle = await rollup(rollOpts)
-      let output = { file: join(fixtures, 'output.js'), format: 'cjs' }
-      await bundle.write(output)
-      assert.is(results.length, 1)
-    })
-  }
+  test(`${version}: treeshaken bundle filters with callback`, async (assert) => {
+    let results
+    let filter = (m) => m.size > 2000
+    let onAnalysis = (r) => { results = r.modules }
+    let plugins = [plugin({ onAnalysis, filter, skipFormatted })]
+    let rollOpts = Object.assign({}, opts, { plugins })
+    let bundle = await rollup(rollOpts)
+    let output = { file: join(fixtures, 'output.js'), format: 'cjs' }
+    await bundle.write(output)
+    assert.is(results.length, 1)
+  })
 
   if (version === '0.60.x') {
     let split1 = `${version}: writes expected heading with experimentalCodeSplitting`