Updating NPM dependencies

node_modules/istanbul-lib-report/lib/tree.js

@@ -4,7 +4,6 @@
  */
 'use strict';
 
-const util = require('util');
 /**
  * An object with methods that are called during the traversal of the coverage tree.
  * A visitor has the following methods that are called during tree traversal.
@@ -23,137 +22,116 @@ const util = require('util');
  *  and nothing else.
  * @constructor
  */
-function Visitor(delegate) {
-    this.delegate = delegate;
-}
-
-['Start', 'End', 'Summary', 'SummaryEnd', 'Detail'].forEach(k => {
-    const f = 'on' + k;
-    Visitor.prototype[f] = function(node, state) {
-        if (this.delegate[f] && typeof this.delegate[f] === 'function') {
-            this.delegate[f].call(this.delegate, node, state);
-        }
-    };
-});
-
-function CompositeVisitor(visitors) {
-    if (!Array.isArray(visitors)) {
-        visitors = [visitors];
+class Visitor {
+    constructor(delegate) {
+        this.delegate = delegate;
     }
-    this.visitors = visitors.map(v => {
-        if (v instanceof Visitor) {
-            return v;
-        }
-        return new Visitor(v);
-    });
 }
 
-util.inherits(CompositeVisitor, Visitor);
-
-['Start', 'Summary', 'SummaryEnd', 'Detail', 'End'].forEach(k => {
-    const f = 'on' + k;
-    CompositeVisitor.prototype[f] = function(node, state) {
-        this.visitors.forEach(v => {
-            v[f](node, state);
+['Start', 'End', 'Summary', 'SummaryEnd', 'Detail']
+    .map(k => `on${k}`)
+    .forEach(fn => {
+        Object.defineProperty(Visitor.prototype, fn, {
+            writable: true,
+            value(node, state) {
+                if (typeof this.delegate[fn] === 'function') {
+                    this.delegate[fn](node, state);
+                }
+            }
         });
-    };
-});
-
-function Node() {}
-
-/* istanbul ignore next: abstract method */
-Node.prototype.getQualifiedName = function() {
-    throw new Error('getQualifiedName must be overridden');
-};
-
-/* istanbul ignore next: abstract method */
-Node.prototype.getRelativeName = function() {
-    throw new Error('getRelativeName must be overridden');
-};
-
-/* istanbul ignore next: abstract method */
-Node.prototype.isRoot = function() {
-    return !this.getParent();
-};
-
-/* istanbul ignore next: abstract method */
-Node.prototype.getParent = function() {
-    throw new Error('getParent must be overridden');
-};
-
-/* istanbul ignore next: abstract method */
-Node.prototype.getChildren = function() {
-    throw new Error('getChildren must be overridden');
-};
-
-/* istanbul ignore next: abstract method */
-Node.prototype.isSummary = function() {
-    throw new Error('isSummary must be overridden');
-};
-
-/* istanbul ignore next: abstract method */
-Node.prototype.getCoverageSummary = function(/* filesOnly */) {
-    throw new Error('getCoverageSummary must be overridden');
-};
-
-/* istanbul ignore next: abstract method */
-Node.prototype.getFileCoverage = function() {
-    throw new Error('getFileCoverage must be overridden');
-};
-/**
- * visit all nodes depth-first from this node down. Note that `onStart`
- * and `onEnd` are never called on the visitor even if the current
- * node is the root of the tree.
- * @param visitor a full visitor that is called during tree traversal
- * @param state optional state that is passed around
- */
-Node.prototype.visit = function(visitor, state) {
-    if (this.isSummary()) {
-        visitor.onSummary(this, state);
-    } else {
-        visitor.onDetail(this, state);
-    }
-
-    this.getChildren().forEach(child => {
-        child.visit(visitor, state);
     });
 
-    if (this.isSummary()) {
-        visitor.onSummaryEnd(this, state);
+class CompositeVisitor extends Visitor {
+    constructor(visitors) {
+        super();
+
+        if (!Array.isArray(visitors)) {
+            visitors = [visitors];
+        }
+        this.visitors = visitors.map(v => {
+            if (v instanceof Visitor) {
+                return v;
+            }
+            return new Visitor(v);
+        });
     }
-};
+}
+
+['Start', 'Summary', 'SummaryEnd', 'Detail', 'End']
+    .map(k => `on${k}`)
+    .forEach(fn => {
+        Object.defineProperty(CompositeVisitor.prototype, fn, {
+            value(node, state) {
+                this.visitors.forEach(v => {
+                    v[fn](node, state);
+                });
+            }
+        });
+    });
+
+class BaseNode {
+    isRoot() {
+        return !this.getParent();
+    }
+
+    /**
+     * visit all nodes depth-first from this node down. Note that `onStart`
+     * and `onEnd` are never called on the visitor even if the current
+     * node is the root of the tree.
+     * @param visitor a full visitor that is called during tree traversal
+     * @param state optional state that is passed around
+     */
+    visit(visitor, state) {
+        if (this.isSummary()) {
+            visitor.onSummary(this, state);
+        } else {
+            visitor.onDetail(this, state);
+        }
+
+        this.getChildren().forEach(child => {
+            child.visit(visitor, state);
+        });
+
+        if (this.isSummary()) {
+            visitor.onSummaryEnd(this, state);
+        }
+    }
+}
 
 /**
  * abstract base class for a coverage tree.
  * @constructor
  */
-function Tree() {}
-
-/**
- * returns the root node of the tree
- */
-/* istanbul ignore next: abstract method */
-Tree.prototype.getRoot = function() {
-    throw new Error('getRoot must be overridden');
-};
-
-/**
- * visits the tree depth-first with the supplied partial visitor
- * @param visitor - a potentially partial visitor
- * @param state - the state to be passed around during tree traversal
- */
-Tree.prototype.visit = function(visitor, state) {
-    if (!(visitor instanceof Visitor)) {
-        visitor = new Visitor(visitor);
+class BaseTree {
+    constructor(root) {
+        this.root = root;
     }
-    visitor.onStart(this.getRoot(), state);
-    this.getRoot().visit(visitor, state);
-    visitor.onEnd(this.getRoot(), state);
-};
+
+    /**
+     * returns the root node of the tree
+     */
+    getRoot() {
+        return this.root;
+    }
+
+    /**
+     * visits the tree depth-first with the supplied partial visitor
+     * @param visitor - a potentially partial visitor
+     * @param state - the state to be passed around during tree traversal
+     */
+    visit(visitor, state) {
+        if (!(visitor instanceof Visitor)) {
+            visitor = new Visitor(visitor);
+        }
+        visitor.onStart(this.getRoot(), state);
+        this.getRoot().visit(visitor, state);
+        visitor.onEnd(this.getRoot(), state);
+    }
+}
 
 module.exports = {
-    Tree,
-    Node,
+    BaseTree,
+    BaseNode,
     Visitor,
     CompositeVisitor
 };