.

node_modules/istanbul-lib-coverage/lib/coverage-map.js

@@ -0,0 +1,127 @@
+/*
+ Copyright 2012-2015, Yahoo Inc.
+ Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+'use strict';
+
+const FileCoverage = require('./file').FileCoverage;
+const CoverageSummary = require('./file').CoverageSummary;
+
+function loadMap(source) {
+    const data = Object.create(null);
+    Object.keys(source).forEach(k => {
+        const cov = source[k];
+        if (cov instanceof FileCoverage) {
+            data[k] = cov;
+        } else {
+            data[k] = new FileCoverage(cov);
+        }
+    });
+    return data;
+}
+/**
+ * CoverageMap is a map of `FileCoverage` objects keyed by file paths.
+ * @param {Object} [obj=undefined] obj A coverage map from which to initialize this
+ * map's contents. This can be the raw global coverage object.
+ * @constructor
+ */
+function CoverageMap(obj) {
+    if (!obj) {
+        this.data = Object.create(null);
+    } else if (obj instanceof CoverageMap) {
+        this.data = obj.data;
+    } else {
+        this.data = loadMap(obj);
+    }
+}
+/**
+ * merges a second coverage map into this one
+ * @param {CoverageMap} obj - a CoverageMap or its raw data. Coverage is merged
+ *  correctly for the same files and additional file coverage keys are created
+ *  as needed.
+ */
+CoverageMap.prototype.merge = function(obj) {
+    let other;
+    if (obj instanceof CoverageMap) {
+        other = obj;
+    } else {
+        other = new CoverageMap(obj);
+    }
+    Object.keys(other.data).forEach(k => {
+        const fc = other.data[k];
+        if (this.data[k]) {
+            this.data[k].merge(fc);
+        } else {
+            this.data[k] = fc;
+        }
+    });
+};
+/**
+ * filter the coveragemap based on the callback provided
+ * @param {Function (filename)} callback - Returns true if the path
+ *  should be included in the coveragemap. False if it should be
+ *  removed.
+ */
+CoverageMap.prototype.filter = function(callback) {
+    Object.keys(this.data).forEach(k => {
+        if (!callback(k)) {
+            delete this.data[k];
+        }
+    });
+};
+/**
+ * returns a JSON-serializable POJO for this coverage map
+ * @returns {Object}
+ */
+CoverageMap.prototype.toJSON = function() {
+    return this.data;
+};
+/**
+ * returns an array for file paths for which this map has coverage
+ * @returns {Array{string}} - array of files
+ */
+CoverageMap.prototype.files = function() {
+    return Object.keys(this.data);
+};
+/**
+ * returns the file coverage for the specified file.
+ * @param {String} file
+ * @returns {FileCoverage}
+ */
+CoverageMap.prototype.fileCoverageFor = function(file) {
+    const fc = this.data[file];
+    if (!fc) {
+        throw new Error('No file coverage available for: ' + file);
+    }
+    return fc;
+};
+/**
+ * adds a file coverage object to this map. If the path for the object,
+ * already exists in the map, it is merged with the existing coverage
+ * otherwise a new key is added to the map.
+ * @param {FileCoverage} fc the file coverage to add
+ */
+CoverageMap.prototype.addFileCoverage = function(fc) {
+    const cov = new FileCoverage(fc);
+    const path = cov.path;
+    if (this.data[path]) {
+        this.data[path].merge(cov);
+    } else {
+        this.data[path] = cov;
+    }
+};
+/**
+ * returns the coverage summary for all the file coverage objects in this map.
+ * @returns {CoverageSummary}
+ */
+CoverageMap.prototype.getCoverageSummary = function() {
+    const ret = new CoverageSummary();
+    this.files().forEach(key => {
+        ret.merge(this.fileCoverageFor(key).toSummary());
+    });
+    return ret;
+};
+
+module.exports = {
+    CoverageMap
+};