Merge pull request #5 from doesdev/2.0.0

2.0.0

Author: doesdev

README.md

@@ -29,10 +29,12 @@ $ npm install --save-dev rollup-analyzer
 ## Usage
 
 ```js
-const rollupAnalyzer = require('rollup-analyzer')({limit: 5})
-rollup.rollup({/*...*/}).then((bundle) => {
+import { rollup } from 'rollup'
+const { formatted } from 'rollup-analyzer'
+
+rollup({/*...*/}).then((bundle) => {
   // print console optimized analysis string
-  rollupAnalyzer.formatted(bundle).then(console.log).catch(console.error)
+  formatted(bundle, {limit: 5}).then(console.log).catch(console.error)
 })
 
 // Results in ...
@@ -59,12 +61,27 @@ dependents: 1
 
 ## API
 
-### rollupAnalyzer
-the default exported function is identical to init, and returns the same functions as export {init, formatted, analyze}. So, you can `require('rollup-analyzer')` or `require('rollup-analyzer')({limit: 5})` and use the same functions.
-
-### rollupAnalyzer.init(options)
-set options to use in analysis (this step is optional)
-- **options** *(Object)*
+Module exports `analyze`, `formatted`, and `plugin` functions
+
+### formatted(bundle, options)
+- arguments
+  - **bundle** *(Rollup Bundle)*
+  - **options** *(Object - see below for available options)*
+- returns
+  - **analysisText** *(String - well formatted for console printing)*
+
+### analyze(bundle, options)
+- arguments
+  - **bundle** *(Rollup Bundle)*
+  - **options** *(Object - see below for available options)*
+- returns
+  - **analysis** *(Object)*
+    - **id** *(String)* - path of module / rollup module id
+    - **size** *(Number)* - size of module in bytes
+    - **dependents** *(Array)* - list of dependent module ids / paths
+    - **percent** *(Number)* - percentage of module size relative to entire bundle
+
+#### options `Object`
   - **limit** - *optional*
     - type: Number
     - default: `null`
@@ -78,20 +95,6 @@ set options to use in analysis (this step is optional)
     - default: `process.cwd()`
     - description: Application directory, used to display file paths relatively
 
-### rollupAnalyzer.formatted(bundle)
-returns Promise which resolves with well formatted analysis string (for CLI printing)
-- **bundle** *(Rollup Bundle)* - *required*
-
-### rollupAnalyzer.analyze(bundle)
-returns Promise which resolves with array of objects describing each imported file
-- **bundle** *(Rollup Bundle)* - *required*
-
-returned array's child analysis objects have the following properties
-- **id** *(String)* - path of module / rollup module id
-- **size** *(Number)* - size of module in bytes
-- **dependents** *(Array)* - list of dependent module ids / paths
-- **percent** *(Number)* - percentage of module size relative to entire bundle
-
 ## License
 
 MIT © [Andrew Carpenter](https://github.com/doesdev)

index.js

@@ -1,14 +1,10 @@
 'use strict';
 
-// Setup
+Object.defineProperty(exports, '__esModule', { value: true });
+
 const buf = ' ';
 const tab = '  ';
 const borderX = `${Array(30).join('-')}\n`;
-let proc = process;
-let root = proc && proc.cwd ? proc.cwd() : null;
-let limit, filter;
-
-// Helpers
 const formatBytes = (bytes) => {
   if (bytes === 0) return '0 Byte'
   let k = 1000;
@@ -18,63 +14,112 @@ const formatBytes = (bytes) => {
   return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i]
 };
 
-// Main
-function init (opts) {
-  opts = opts || {};
-  limit = opts.limit;
-  filter = opts.filter;
-  root = opts.root || root;
-}
-
-function analyzer (opts) {
-  init(opts);
-  return {init, formatted, analyze}
-}
-analyzer.init = init;
-analyzer.formatted = formatted;
-analyzer.analyze = analyze;
-
-function formatted (bndl) { return analyze(bndl, true) }
-
-function analyze (bundle, format) {
+const analyze = (bundle, opts = {}, format = false) => {
+  let { root, limit, filter } = opts;
   let deps = {};
+  let entrySize;
   let bundleSize = 0;
+  let bundleModules = bundle.modules;
+
   return new Promise((resolve, reject) => {
-    let modules = bundle.modules.map((m, i) => {
-      let id = m.id.replace(root, '');
-      let size = Buffer.byteLength(m.code, 'utf8') || 0;
+    let modules = bundleModules.map((m, i) => {
+      let { id, originalLength: origSize, renderedLength, isEntry, code } = m;
+      id = id.replace(root, '');
+      let size = renderedLength;
+      if (!size && size !== 0) size = code ? Buffer.byteLength(code, 'utf8') : 0;
+      if (isEntry) entrySize = size;
       bundleSize += size;
+
       if (Array.isArray(filter) && !filter.some((f) => id.match(f))) return null
-      else if (typeof filter === 'string' && !id.match(filter)) return null
+      if (typeof filter === 'string' && !id.match(filter)) return null
+
       m.dependencies.forEach((d) => {
         d = d.replace(root, '');
         deps[d] = deps[d] || [];
         deps[d].push(id);
       });
-      return {id, size}
+
+      return {id, size, origSize, isEntry}
     }).filter((m) => m);
+
+    if (entrySize) bundleSize = entrySize;
+
     modules.sort((a, b) => b.size - a.size);
     if (limit || limit === 0) modules = modules.slice(0, limit);
     modules.forEach((m) => {
       m.dependents = deps[m.id] || [];
       m.percent = ((m.size / bundleSize) * 100).toFixed(2);
+      m.reduction = 100 - ((m.size / m.origSize) * 100).toFixed(2);
     });
+
     if (!format) return resolve(modules)
+
     let heading = `Rollup File Analysis\n`;
     let displaySize = `${borderX}bundle size: ${formatBytes(bundleSize)}\n`;
     let formatted = `${borderX}${heading}${displaySize}${borderX}`;
+
     modules.forEach((m) => {
+      if (m.isEntry) return
       formatted += `file:${buf}${m.id}\n`;
       formatted += `size:${buf}${formatBytes(m.size)}\n`;
       formatted += `percent:${buf}${m.percent}%\n`;
+      formatted += `orig. size:${buf}${formatBytes(m.origSize || 'unknown')}\n`;
+      formatted += `code reduction:${buf}${m.reduction}%\n`;
       formatted += `dependents:${buf}${m.dependents.length}\n`;
       m.dependents.forEach((d) => {
         formatted += `${tab}-${buf}${d.replace(root, '')}\n`;
       });
       formatted += `${borderX}`;
     });
+
     return resolve(formatted)
   })
-}
+};
+
+const formatted = (bndl, opts) => analyze(bndl, opts, true);
+
+const plugin = (opts = {}) => {
+  let cb = opts.writeTo || (opts.stdout ? console.log : console.error);
+  if (opts.onAnalysis) cb = opts.onAnalysis;
+  let written;
+  let modules;
+
+  let runAnalysis = (out, bundle, isWrite) => new Promise((resolve, reject) => {
+    resolve();
+    if (written) return
+    written = true;
+    if (out.bundle) bundle = out.bundle;
+    if (!Array.isArray(bundle.modules)) {
+      modules.forEach((m) => {
+        let bm = bundle.modules[m.id];
+        bm.id = bm.id || m.id;
+        bm.isEntry = bm.isEntry || m.isEntry;
+        bm.dependencies = m.dependencies || [];
+      });
+      modules = Object.keys(bundle.modules).map((k) => bundle.modules[k]);
+    } else {
+      modules = bundle.modules;
+    }
+    return analyze({modules}, opts, !opts.onAnalysis).then(cb)
+  });
+  return {
+    name: 'rollup-analyzer-plugin',
+    transformChunk: (_a, _b, chunk) => new Promise((resolve, reject) => {
+      resolve(null);
+      if (!chunk || !chunk.orderedModules) return
+      modules = chunk.orderedModules.map((m) => {
+        return {
+          id: m.id,
+          isEntry: m.isEntryPoint,
+          dependencies: m.dependencies.map((d) => d.id)
+        }
+      });
+    }),
+    generateBundle: runAnalysis,
+    ongenerate: runAnalysis
+  }
+};
 
-module.exports = analyzer;
+exports.analyze = analyze;
+exports.formatted = formatted;
+exports.plugin = plugin;

module.js

@@ -1,14 +1,8 @@
 'use strict'
 
-// Setup
 const buf = ' '
 const tab = '  '
 const borderX = `${Array(30).join('-')}\n`
-let proc = process
-let root = proc && proc.cwd ? proc.cwd() : null
-let limit, filter
-
-// Helpers
 const formatBytes = (bytes) => {
   if (bytes === 0) return '0 Byte'
   let k = 1000
@@ -18,64 +12,108 @@ const formatBytes = (bytes) => {
   return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i]
 }
 
-// Exports
-export default analyzer
-
-// Main
-function init (opts) {
-  opts = opts || {}
-  limit = opts.limit
-  filter = opts.filter
-  root = opts.root || root
-}
-
-function analyzer (opts) {
-  init(opts)
-  return {init, formatted, analyze}
-}
-analyzer.init = init
-analyzer.formatted = formatted
-analyzer.analyze = analyze
-
-function formatted (bndl) { return analyze(bndl, true) }
-
-function analyze (bundle, format) {
+export const analyze = (bundle, opts = {}, format = false) => {
+  let { root, limit, filter } = opts
   let deps = {}
+  let entrySize
   let bundleSize = 0
+  let bundleModules = bundle.modules
+
   return new Promise((resolve, reject) => {
-    let modules = bundle.modules.map((m, i) => {
-      let id = m.id.replace(root, '')
-      let size = Buffer.byteLength(m.code, 'utf8') || 0
+    let modules = bundleModules.map((m, i) => {
+      let { id, originalLength: origSize, renderedLength, isEntry, code } = m
+      id = id.replace(root, '')
+      let size = renderedLength
+      if (!size && size !== 0) size = code ? Buffer.byteLength(code, 'utf8') : 0
+      if (isEntry) entrySize = size
       bundleSize += size
+
       if (Array.isArray(filter) && !filter.some((f) => id.match(f))) return null
-      else if (typeof filter === 'string' && !id.match(filter)) return null
+      if (typeof filter === 'string' && !id.match(filter)) return null
+
       m.dependencies.forEach((d) => {
         d = d.replace(root, '')
         deps[d] = deps[d] || []
         deps[d].push(id)
       })
-      return {id, size}
+
+      return {id, size, origSize, isEntry}
     }).filter((m) => m)
+
+    if (entrySize) bundleSize = entrySize
+
     modules.sort((a, b) => b.size - a.size)
     if (limit || limit === 0) modules = modules.slice(0, limit)
     modules.forEach((m) => {
       m.dependents = deps[m.id] || []
       m.percent = ((m.size / bundleSize) * 100).toFixed(2)
+      m.reduction = 100 - ((m.size / m.origSize) * 100).toFixed(2)
     })
+
     if (!format) return resolve(modules)
+
     let heading = `Rollup File Analysis\n`
     let displaySize = `${borderX}bundle size: ${formatBytes(bundleSize)}\n`
     let formatted = `${borderX}${heading}${displaySize}${borderX}`
+
     modules.forEach((m) => {
+      if (m.isEntry) return
       formatted += `file:${buf}${m.id}\n`
       formatted += `size:${buf}${formatBytes(m.size)}\n`
       formatted += `percent:${buf}${m.percent}%\n`
+      formatted += `orig. size:${buf}${formatBytes(m.origSize || 'unknown')}\n`
+      formatted += `code reduction:${buf}${m.reduction}%\n`
       formatted += `dependents:${buf}${m.dependents.length}\n`
       m.dependents.forEach((d) => {
         formatted += `${tab}-${buf}${d.replace(root, '')}\n`
       })
       formatted += `${borderX}`
     })
+
     return resolve(formatted)
   })
 }
+
+export const formatted = (bndl, opts) => analyze(bndl, opts, true)
+
+export const plugin = (opts = {}) => {
+  let cb = opts.writeTo || (opts.stdout ? console.log : console.error)
+  if (opts.onAnalysis) cb = opts.onAnalysis
+  let written
+  let modules
+
+  let runAnalysis = (out, bundle, isWrite) => new Promise((resolve, reject) => {
+    resolve()
+    if (written) return
+    written = true
+    if (out.bundle) bundle = out.bundle
+    if (!Array.isArray(bundle.modules)) {
+      modules.forEach((m) => {
+        let bm = bundle.modules[m.id]
+        bm.id = bm.id || m.id
+        bm.isEntry = bm.isEntry || m.isEntry
+        bm.dependencies = m.dependencies || []
+      })
+      modules = Object.keys(bundle.modules).map((k) => bundle.modules[k])
+    } else {
+      modules = bundle.modules
+    }
+    return analyze({modules}, opts, !opts.onAnalysis).then(cb)
+  })
+  return {
+    name: 'rollup-analyzer-plugin',
+    transformChunk: (_a, _b, chunk) => new Promise((resolve, reject) => {
+      resolve(null)
+      if (!chunk || !chunk.orderedModules) return
+      modules = chunk.orderedModules.map((m) => {
+        return {
+          id: m.id,
+          isEntry: m.isEntryPoint,
+          dependencies: m.dependencies.map((d) => d.id)
+        }
+      })
+    }),
+    generateBundle: runAnalysis,
+    ongenerate: runAnalysis
+  }
+}