Add failing tests, updates readme, standard fixes

Doing some maintenance prior to the next minor release. Added a test
for the not yet implemented transformModuleId. Also added stub for
htmlReportPath test. Fixed object literal notation to match updated
standardjs specs. Added documentation for transformModuleId.

Author: doesdev

.gitignore

@@ -40,3 +40,4 @@ jspm_packages
 # Output files
 test/fixtures/output.js
 test/fixtures/multi
+test/fixtures/report.html

LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2016 Andrew Carpenter
+Copyright (c) 2018 Andrew Carpenter
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -139,13 +139,26 @@ dependents:      1
   - type: Function
   - default: `null`
   - description: Callback to be invoked with formatted string
-  - callback invoked with:
+  - function will be invoked with:
     - **analysisString** *(String)*
+- **htmlReportPath** - *optional*
+  - type: String
+  - default: `null`
+  - description: Write HTML report to this path
+- **transformModuleId** - *optional*
+  - type: Function
+  - default: `null`
+  - description: Modify module ids
+  - function will be invoked with:
+    - **id** *(String)* - path of module / rollup module id
+  - function should return:
+    - **id** *(String)* - desired final module id to display in analysis results
+  - example: `(id) => id.replace(/^\0(?:commonjs-proxy:)?/, '')`
 - **onAnalysis** - *optional*
   - type: Function
   - default: `null`
   - description: Callback to be invoked with analysis object
-  - callback invoked with:
+  - function will be invoked with:
     - **analysisObject** *(Object)*
       - **bundleSize** *(Number)* - rendered bundle size in bytes
       - **bundleOrigSize** *(Number)* - original bundle size in bytes
@@ -161,10 +174,6 @@ dependents:      1
           - **reduction** *(Number)* - percentage of rendered size reduction
           - **usedExports** *(Array)* - list of used named exports
           - **unusedExports** *(Array)* - list of unused named exports
-- **htmlReportPath** - *optional*
-  - type: String
-  - default: `null`
-  - description: Write HTML report to this path
 
 ## Other considerations
 

module.js

@@ -91,7 +91,7 @@ const analyzer = (bundle, opts = {}) => {
       deps[d].push(id)
     })
 
-    return {id, size, origSize, usedExports, unusedExports}
+    return { id, size, origSize, usedExports, unusedExports }
   }).filter((m) => m)
 
   modules.sort((a, b) => b.size - a.size)
@@ -105,7 +105,7 @@ const analyzer = (bundle, opts = {}) => {
 
   let bundleReduction = shakenPct(bundleSize, bundleOrigSize)
 
-  return {bundleSize, bundleOrigSize, bundleReduction, modules, moduleCount}
+  return { bundleSize, bundleOrigSize, bundleReduction, modules, moduleCount }
 }
 
 export const analyze = (bundle, opts) => new Promise((resolve, reject) => {
@@ -138,7 +138,7 @@ export const plugin = (opts = {}) => {
     let modules = bundle.modules
 
     if (Array.isArray(modules)) {
-      return analyze({modules}, opts).then(onAnalysis).catch(console.error)
+      return analyze({ modules }, opts).then(onAnalysis).catch(console.error)
     }
 
     modules = Object.keys(modules).map((k) => {
@@ -147,16 +147,16 @@ export const plugin = (opts = {}) => {
       module.unusedExports = module.removedExports
       return module
     })
-    return analyze({modules}, opts).then(onAnalysis).catch(console.error)
+    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)}
+      chunk.orderedModules.forEach(({ id, dependencies }) => {
+        depMap[id] = { id, dependencies: dependencies.map((d) => d.id) }
       })
     }),
     generateBundle: runAnalysis,

test/test.js

@@ -2,8 +2,9 @@
 
 // setup
 import test from 'ava'
+// import { promises as fs } from 'fs'
 import { analyze, formatted, plugin } from './../index'
-import { resolve, join } from 'path'
+import { resolve, join, basename } from 'path'
 import { rollup as rollupLatest } from 'rollup'
 import { rollup as rollup60 } from 'rollup60'
 import { rollup as rollup55 } from 'rollup55'
@@ -14,15 +15,15 @@ const skipFormatted = true
 const fixtures = resolve(__dirname, 'fixtures')
 const baseOpts = {
   input: join(fixtures, 'bundle-a.js'),
-  output: {format: 'cjs'}
+  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')}
+  output: { format: 'cjs', dir: join(fixtures, 'multi') }
 }
 const expectHeader = `
 -----------------------------
@@ -33,16 +34,16 @@ 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: 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 }
 ]
 
 // main
-rollers.forEach(({rollup, version, opts, noTreeshake}) => {
+rollers.forEach(({ rollup, version, opts, noTreeshake }) => {
   test(`${version}: formatted returns expected string`, async (assert) => {
     let bundle = await rollup(opts)
     let results = await formatted(bundle)
@@ -71,52 +72,61 @@ rollers.forEach(({rollup, version, opts, noTreeshake}) => {
 
   test(`${version}: limit works`, async (assert) => {
     let bundle = await rollup(opts)
-    assert.is((await analyze(bundle, {limit: 0})).modules.length, 0)
-    assert.is((await analyze(bundle, {limit: 1})).modules.length, 1)
-    assert.is((await analyze(bundle, {limit: 0})).modules.length, 0)
+    assert.is((await analyze(bundle, { limit: 0 })).modules.length, 0)
+    assert.is((await analyze(bundle, { limit: 1 })).modules.length, 1)
+    assert.is((await analyze(bundle, { limit: 0 })).modules.length, 0)
   })
 
   test(`${version}: filter with array works`, async (assert) => {
     let bundle = await rollup(opts)
     assert.is(
-      (await analyze(bundle, {filter: ['jimmy', 'jerry']})).modules.length,
+      (await analyze(bundle, { filter: ['jimmy', 'jerry'] })).modules.length,
       0
     )
     assert.is(
-      (await analyze(bundle, {filter: ['import-a', 'jessie']})).modules.length,
+      (await analyze(bundle, { filter: ['import-a', 'jessie'] })).modules.length,
       1
     )
   })
 
   test(`${version}: filter with string works`, async (assert) => {
     let bundle = await rollup(opts)
-    assert.is((await analyze(bundle, {filter: 'jimmy'})).modules.length, 0)
-    assert.is((await analyze(bundle, {filter: 'import-b'})).modules.length, 1)
+    assert.is((await analyze(bundle, { filter: 'jimmy' })).modules.length, 0)
+    assert.is((await analyze(bundle, { filter: 'import-b' })).modules.length, 1)
   })
 
   test(`${version}: filter with callback works`, async (assert) => {
     let bundle = await rollup(opts)
     let noMatch = (m) => m.id.indexOf('jimmy') !== -1
     let hasMatch = (m) => m.id.indexOf('import-b') !== -1
-    assert.is((await analyze(bundle, {filter: noMatch})).modules.length, 0)
-    assert.is((await analyze(bundle, {filter: hasMatch})).modules.length, 1)
+    assert.is((await analyze(bundle, { filter: noMatch })).modules.length, 0)
+    assert.is((await analyze(bundle, { filter: hasMatch })).modules.length, 1)
+  })
+
+  test.failing(`${version}: transformModuleId works`, async (assert) => {
+    let bundle = await rollup(opts)
+    let transformModuleId = (id) => `transformed-${id}`
+    let expect = `transformed-import-a`
+    let modules = (await analyze(bundle, { transformModuleId })).modules
+    let firstModule = basename(modules[0].id)
+    assert.is(firstModule, expect)
   })
 
   test(`${version}: root works as expected`, async (assert) => {
     let bundle = await rollup(opts)
     assert.not(
-      join(__dirname, (await analyze(bundle, {root: 'fakepath'})).modules[0].id),
+      join(__dirname, (await analyze(bundle, { root: 'fakepath' })).modules[0].id),
       resolve(fixtures, 'import-a.js')
     )
     assert.is(
-      join(__dirname, (await analyze(bundle, {root: __dirname})).modules[0].id),
+      join(__dirname, (await analyze(bundle, { root: __dirname })).modules[0].id),
       resolve(fixtures, 'import-a.js')
     )
   })
 
   test(`${version}: it works with generated bundle as well`, async (assert) => {
     let bundle = await rollup(opts)
-    await bundle.generate({format: 'cjs'})
+    await bundle.generate({ format: 'cjs' })
     let results = await formatted(bundle)
     assert.is(typeof results, 'string')
   })
@@ -125,33 +135,41 @@ rollers.forEach(({rollup, version, opts, noTreeshake}) => {
     let results
     let writeTo = (r) => { results = r }
     let showExports = true
-    let rollOpts = Object.assign({plugins: [plugin({writeTo, showExports})]}, opts)
+    let rollOpts = Object.assign(
+      { plugins: [plugin({ writeTo, showExports })] },
+      opts
+    )
     let bundle = await rollup(rollOpts)
-    await bundle.generate({format: 'cjs'})
+    await bundle.generate({ format: 'cjs' })
     assert.is(results.substr(0, expectHeader.length), expectHeader)
   })
 
+  test.failing(`${version}: htmlReportPath produces report`, async (assert) => {
+    assert.true(false)
+  })
+
   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 plugins = [plugin({ onAnalysis, skipFormatted })]
+      let rollOpts = Object.assign({}, opts, { plugins })
       let bundle = await rollup(rollOpts)
-      let output = {file: join(fixtures, 'output.js'), format: 'cjs'}
+      let output = { file: join(fixtures, 'output.js'), format: 'cjs' }
       await bundle.write(output)
       let imported = results.find((r) => r.id.indexOf('import-a') !== -1)
-      assert.is(imported.size, 27)
+      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 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'}
+      let output = { file: join(fixtures, 'output.js'), format: 'cjs' }
       await bundle.write(output)
       assert.is(results.length, 1)
     })
@@ -162,39 +180,45 @@ rollers.forEach(({rollup, version, opts, noTreeshake}) => {
     test(split1, async (assert) => {
       let results
       let writeTo = (r) => { results = r }
-      let rollOpts = Object.assign({plugins: [plugin({writeTo})]}, multiInputOpts)
+      let rollOpts = Object.assign(
+        { plugins: [plugin({ writeTo })] },
+        multiInputOpts
+      )
       rollOpts.experimentalCodeSplitting = true
       let bundle = await rollup(rollOpts)
-      await bundle.generate({format: 'cjs'})
+      await bundle.generate({ format: 'cjs' })
       assert.is(results.substr(0, expectHeader.length), expectHeader)
     })
 
     let split2 = `${version}: data as expected with experimentalCodeSplitting`
     test(split2, async (assert) => {
       let results = []
       let onAnalysis = (r) => { results.push(r.modules) }
-      let plugins = [plugin({onAnalysis, skipFormatted})]
-      let rollOpts = Object.assign({}, multiInputOpts, {plugins})
+      let plugins = [plugin({ onAnalysis, skipFormatted })]
+      let rollOpts = Object.assign({}, multiInputOpts, { plugins })
       rollOpts.experimentalCodeSplitting = true
       let bundle = await rollup(rollOpts)
       await bundle.write(rollOpts.output)
 
-      let imports = [{id: 'import-a', size: 8238}, {id: 'import-b', size: 33}]
+      let imports = [{ id: 'import-a', size: 8238 }, { id: 'import-b', size: 33 }]
       imports.forEach((imp, i) => {
         let result = results[i]
         let imported = result.find((r) => r.id.indexOf(imp.id) !== -1)
-        assert.is(imported.size, imp.size)
+        assert.true(Math.abs(imported.size - imp.size) < 5)
       })
     })
 
     test.failing(`${version}: callback is only invoked once`, async (assert) => {
       let count = 0
       let writeTo = () => ++count
 
-      let rollOpts = Object.assign({plugins: [plugin({writeTo})]}, multiInputOpts)
+      let rollOpts = Object.assign(
+        { plugins: [plugin({ writeTo })] },
+        multiInputOpts
+      )
       rollOpts.experimentalCodeSplitting = true
       let bundle = await rollup(rollOpts)
-      await bundle.generate({format: 'cjs'})
+      await bundle.generate({ format: 'cjs' })
 
       assert.is(count, 1)
     })
@@ -210,18 +234,18 @@ rollers.forEach(({rollup, version, opts, noTreeshake}) => {
       start = Date.now()
       for (let i = 0; i < runs; i++) {
         let bundle = await rollup(opts)
-        await bundle.generate({format: 'cjs'})
+        await bundle.generate({ format: 'cjs' })
       }
       let noPlugin = (Date.now() - start) / runs
 
       // now with the plugin
       let count = 0
       let writeTo = (r) => ++count
-      let rollOpts = Object.assign({plugins: [plugin({writeTo})]}, opts)
+      let rollOpts = Object.assign({ plugins: [plugin({ writeTo })] }, opts)
       start = Date.now()
       for (let i = 0; i < runs; i++) {
         let bundle = await rollup(rollOpts)
-        await bundle.generate({format: 'cjs'})
+        await bundle.generate({ format: 'cjs' })
       }
       let withPlugin = (Date.now() - start) / runs