Updated the files.

my-app/node_modules/karma-coverage/lib/coverage-map.js

@@ -0,0 +1,22 @@
+// Coverage Map
+// ============
+
+var coverageMap = {}
+
+function add (coverageObj) {
+  coverageMap[coverageObj.path] = coverageObj
+}
+
+function get () {
+  return coverageMap
+}
+
+function reset () {
+  coverageMap = {}
+}
+
+module.exports = {
+  add: add,
+  get: get,
+  reset: reset
+}

my-app/node_modules/karma-coverage/lib/in-memory-report.js

@@ -0,0 +1,29 @@
+const { ReportBase } = require('istanbul-lib-report')
+
+class InMemoryReport extends ReportBase {
+  constructor (opt) {
+    super(opt)
+    this.opt = opt
+  }
+
+  onStart () {
+    this.data = {}
+  }
+
+  onDetail (node) {
+    const fc = node.getFileCoverage()
+    const key = fc.path
+    this.data[key] = fc.toJSON()
+  }
+
+  onEnd () {
+    if (!this.opt || !this.opt.emitter || !this.opt.emitter.emit) {
+      console.error('Could not raise "coverage_complete" event, missing emitter because it was not supplied during initialization of the reporter')
+      return
+    }
+    this.opt.emitter.emit('coverage_complete', this.opt.browser, this.data)
+  }
+}
+InMemoryReport.TYPE = 'in-memory'
+
+module.exports = InMemoryReport

my-app/node_modules/karma-coverage/lib/index.js

@@ -0,0 +1,13 @@
+// karma-coverage
+// ==============
+//
+// Main entry point for the karma-coverage module.
+// Exposes the preprocessor and reporter plugins.
+
+// Registering one additional (karma specific) reporter: in-memory
+require('./report-creator').register(require('./in-memory-report'))
+
+module.exports = {
+  'preprocessor:coverage': ['factory', require('./preprocessor')],
+  'reporter:coverage': ['type', require('./reporter')]
+}

my-app/node_modules/karma-coverage/lib/preprocessor.js

@@ -0,0 +1,201 @@
+// Coverage Preprocessor
+// =====================
+//
+// Depends on the the reporter to generate an actual report
+
+// Dependencies
+// ------------
+
+const { createInstrumenter } = require('istanbul-lib-instrument')
+const minimatch = require('minimatch')
+const path = require('path')
+const globalSourceMapStore = require('./source-map-store')
+const globalCoverageMap = require('./coverage-map')
+
+// Regexes
+// -------
+
+const coverageObjRegex = /\{.*"path".*"fnMap".*"statementMap".*"branchMap".*\}/g
+
+// Preprocessor creator function
+function createCoveragePreprocessor (logger, basePath, reporters = [], coverageReporter = {}) {
+  const log = logger.create('preprocessor.coverage')
+
+  // Options
+  // -------
+
+  function isConstructor (Func) {
+    try {
+      // eslint-disable-next-line
+      new Func()
+    } catch (err) {
+      // error message should be of the form: "TypeError: func is not a constructor"
+      // test for this type of message to ensure we failed due to the function not being
+      // constructable
+      if (/TypeError.*constructor/.test(err.message)) {
+        return false
+      }
+    }
+    return true
+  }
+
+  function getCreatorFunction (Obj) {
+    if (Obj.Instrumenter) {
+      return function (opts) {
+        return new Obj.Instrumenter(opts)
+      }
+    }
+    if (typeof Obj !== 'function') {
+      // Object doesn't have old instrumenter variable and isn't a
+      // constructor, so we can't use it to create an instrumenter
+      return null
+    }
+    if (isConstructor(Obj)) {
+      return function (opts) {
+        return new Obj(opts)
+      }
+    }
+    return Obj
+  }
+
+  const instrumenters = { istanbul: createInstrumenter }
+  const instrumenterOverrides = coverageReporter.instrumenter || {}
+  const { includeAllSources = false, useJSExtensionForCoffeeScript = false } = coverageReporter
+
+  Object.entries(coverageReporter.instrumenters || {}).forEach(([literal, instrumenter]) => {
+    const creatorFunction = getCreatorFunction(instrumenter)
+    if (creatorFunction) {
+      instrumenters[literal] = creatorFunction
+    }
+  })
+
+  const sourceMapStore = globalSourceMapStore.get(basePath)
+
+  const instrumentersOptions = Object.keys(instrumenters).reduce((memo, key) => {
+    memo[key] = {}
+
+    if (coverageReporter.instrumenterOptions) {
+      memo[key] = coverageReporter.instrumenterOptions[key]
+    }
+
+    return memo
+  }, {})
+
+  // if coverage reporter is not used, do not preprocess the files
+  if (!reporters.includes('coverage')) {
+    log.info('coverage not included in reporters %s', reporters)
+    return function (content, _, done) {
+      done(content)
+    }
+  }
+  log.debug('coverage included in reporters %s', reporters)
+
+  // check instrumenter override requests
+  function checkInstrumenters () {
+    const keys = Object.keys(instrumenters)
+    return Object.values(instrumenterOverrides).some(literal => {
+      const notIncluded = !keys.includes(String(literal))
+      if (notIncluded) {
+        log.error('Unknown instrumenter: %s', literal)
+      }
+      return notIncluded
+    })
+  }
+
+  if (checkInstrumenters()) {
+    return function (content, _, done) {
+      return done(1)
+    }
+  }
+
+  return function (content, file, done) {
+    log.debug('Processing "%s".', file.originalPath)
+
+    const jsPath = path.resolve(file.originalPath)
+    // 'istanbul' is default instrumenters
+    const instrumenterLiteral = Object.keys(instrumenterOverrides).reduce((res, pattern) => {
+      if (minimatch(file.originalPath, pattern, { dot: true })) {
+        return instrumenterOverrides[pattern]
+      }
+      return res
+    }, 'istanbul')
+
+    const instrumenterCreator = instrumenters[instrumenterLiteral]
+    const constructOptions = instrumentersOptions[instrumenterLiteral] || {}
+    let options = Object.assign({}, constructOptions)
+    let codeGenerationOptions = null
+    options.autoWrap = options.autoWrap || !options.noAutoWrap
+
+    if (file.sourceMap) {
+      log.debug('Enabling source map generation for "%s".', file.originalPath)
+      codeGenerationOptions = Object.assign({}, {
+        format: {
+          compact: !constructOptions.noCompact
+        },
+        sourceMap: file.sourceMap.file,
+        sourceMapWithCode: true,
+        file: file.path
+      }, constructOptions.codeGenerationOptions || {})
+      options.produceSourceMap = true
+    }
+
+    options = Object.assign({}, options, { codeGenerationOptions: codeGenerationOptions })
+
+    const instrumenter = instrumenterCreator(options)
+    instrumenter.instrument(content, jsPath, function (err, instrumentedCode) {
+      if (err) {
+        log.error('%s\n  at %s', err.message, file.originalPath)
+        done(err.message)
+      } else {
+        // Register the incoming sourceMap for transformation during reporting (if it exists)
+        if (file.sourceMap) {
+          sourceMapStore.registerMap(jsPath, file.sourceMap)
+        }
+
+        // Add merged source map (if it merged correctly)
+        const lastSourceMap = instrumenter.lastSourceMap()
+        if (lastSourceMap) {
+          log.debug('Adding source map to instrumented file for "%s".', file.originalPath)
+          file.sourceMap = lastSourceMap
+          instrumentedCode += '\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,'
+          instrumentedCode += Buffer.from(JSON.stringify(lastSourceMap)).toString('base64') + '\n'
+        }
+
+        if (includeAllSources) {
+          let coverageObj
+          // Check if the file coverage object is exposed from the instrumenter directly
+          if (instrumenter.lastFileCoverage) {
+            coverageObj = instrumenter.lastFileCoverage()
+            globalCoverageMap.add(coverageObj)
+          } else {
+            // Attempt to match and parse coverage object from instrumented code
+
+            // reset stateful regex
+            coverageObjRegex.lastIndex = 0
+            const coverageObjMatch = coverageObjRegex.exec(instrumentedCode)
+            if (coverageObjMatch !== null) {
+              coverageObj = JSON.parse(coverageObjMatch[0])
+              globalCoverageMap.add(coverageObj)
+            }
+          }
+        }
+
+        // RequireJS expects JavaScript files to end with `.js`
+        if (useJSExtensionForCoffeeScript && instrumenterLiteral === 'ibrik') {
+          file.path = file.path.replace(/\.coffee$/, '.js')
+        }
+
+        done(instrumentedCode)
+      }
+    }, file.sourceMap)
+  }
+}
+
+createCoveragePreprocessor.$inject = [
+  'logger',
+  'config.basePath',
+  'config.reporters',
+  'config.coverageReporter'
+]
+
+module.exports = createCoveragePreprocessor

my-app/node_modules/karma-coverage/lib/report-creator.js

@@ -0,0 +1,41 @@
+// Report Creator
+// ==============
+//
+// Wrapper of Istanbul's report creator to allow registering
+// custom reporters
+
+// Dependencies
+// ------------
+var istanbulReports = require('istanbul-reports')
+
+var customReporterMap = {}
+
+function register (reporter) {
+  var registeredType = reporter.TYPE
+  if (!registeredType) {
+    throw new Error('Registering a custom reporter requires a type!')
+  }
+
+  customReporterMap[registeredType] = reporter
+  return registeredType
+}
+
+function create (type, opts) {
+  var Reporter = customReporterMap[type]
+  if (Reporter) {
+    return new Reporter(opts)
+  }
+
+  // fallback to istanbul's report creator if reporter isn't found
+  return istanbulReports.create(type, opts)
+}
+
+function reset () {
+  customReporterMap = {}
+}
+
+module.exports = {
+  create: create,
+  register: register,
+  reset: reset
+}

my-app/node_modules/karma-coverage/lib/reporter.js

@@ -0,0 +1,314 @@
+// Coverage Reporter
+// Part of this code is based on [1], which is licensed under the New BSD License.
+// For more information see the See the accompanying LICENSE-istanbul file for terms.
+//
+// [1]: https://github.com/gotwarlost/istanbul/blob/master/lib/command/check-coverage.js
+// =====================
+//
+// Generates the report
+
+// Dependencies
+// ------------
+
+var path = require('path')
+const { promisify } = require('util')
+var istanbulLibCoverage = require('istanbul-lib-coverage')
+var istanbulLibReport = require('istanbul-lib-report')
+var minimatch = require('minimatch')
+
+var globalSourceMapStore = require('./source-map-store')
+var globalCoverageMap = require('./coverage-map')
+var reports = require('./report-creator')
+const hasOwnProperty = Object.prototype.hasOwnProperty
+
+// TODO(vojta): inject only what required (config.basePath, config.coverageReporter)
+var CoverageReporter = function (rootConfig, helper, logger, emitter) {
+  var log = logger.create('coverage')
+
+  // Instance variables
+  // ------------------
+
+  this.adapters = []
+
+  // Options
+  // -------
+
+  var config = rootConfig.coverageReporter || {}
+  var basePath = rootConfig.basePath
+  var reporters = config.reporters
+  var sourceMapStore = globalSourceMapStore.get(basePath)
+  var includeAllSources = config.includeAllSources === true
+
+  if (config.watermarks) {
+    config.watermarks = helper.merge({}, istanbulLibReport.getDefaultWatermarks(), config.watermarks)
+  }
+
+  if (!helper.isDefined(reporters)) {
+    reporters = [config]
+  }
+
+  var coverageMaps
+
+  function normalize (key) {
+    // Exclude keys will always be relative, but covObj keys can be absolute or relative
+    var excludeKey = path.isAbsolute(key) ? path.relative(basePath, key) : key
+    // Also normalize for files that start with `./`, etc.
+    excludeKey = path.normalize(excludeKey)
+
+    return excludeKey
+  }
+
+  function getTrackedFiles (coverageMap, patterns) {
+    var files = []
+
+    coverageMap.files().forEach(function (key) {
+      // Do any patterns match the resolved key
+      var found = patterns.some(function (pattern) {
+        return minimatch(normalize(key), pattern, { dot: true })
+      })
+
+      // if no patterns match, keep the key
+      if (!found) {
+        files.push(key)
+      }
+    })
+
+    return files
+  }
+
+  function overrideThresholds (key, overrides) {
+    var thresholds = {}
+
+    // First match wins
+    Object.keys(overrides).some(function (pattern) {
+      if (minimatch(normalize(key), pattern, { dot: true })) {
+        thresholds = overrides[pattern]
+        return true
+      }
+    })
+
+    return thresholds
+  }
+
+  function checkCoverage (browser, coverageMap) {
+    var defaultThresholds = {
+      global: {
+        statements: 0,
+        branches: 0,
+        lines: 0,
+        functions: 0,
+        excludes: []
+      },
+      each: {
+        statements: 0,
+        branches: 0,
+        lines: 0,
+        functions: 0,
+        excludes: [],
+        overrides: {}
+      }
+    }
+
+    var thresholds = helper.merge({}, defaultThresholds, config.check)
+
+    var globalTrackedFiles = getTrackedFiles(coverageMap, thresholds.global.excludes)
+    var eachTrackedFiles = getTrackedFiles(coverageMap, thresholds.each.excludes)
+    var globalResults = istanbulLibCoverage.createCoverageSummary()
+    var eachResults = {}
+    globalTrackedFiles.forEach(function (f) {
+      var fileCoverage = coverageMap.fileCoverageFor(f)
+      var summary = fileCoverage.toSummary()
+      globalResults.merge(summary)
+    })
+    eachTrackedFiles.forEach(function (f) {
+      var fileCoverage = coverageMap.fileCoverageFor(f)
+      var summary = fileCoverage.toSummary()
+      eachResults[f] = summary
+    })
+
+    var coverageFailed = false
+    const { emitWarning = false } = thresholds
+
+    function check (name, thresholds, actuals) {
+      var keys = [
+        'statements',
+        'branches',
+        'lines',
+        'functions'
+      ]
+
+      keys.forEach(function (key) {
+        var actual = actuals[key].pct
+        var actualUncovered = actuals[key].total - actuals[key].covered
+        var threshold = thresholds[key]
+
+        if (threshold < 0) {
+          if (threshold * -1 < actualUncovered) {
+            coverageFailed = true
+            log.error(browser.name + ': Uncovered count for ' + key + ' (' + actualUncovered +
+              ') exceeds ' + name + ' threshold (' + -1 * threshold + ')')
+          }
+        } else if (actual < threshold) {
+          const message = `${browser.name}: Coverage for ${key} (${actual}%) does not meet ${name} threshold (${threshold}%)`
+          if (emitWarning) {
+            log.warn(message)
+          } else {
+            coverageFailed = true
+            log.error(message)
+          }
+        }
+      })
+    }
+
+    check('global', thresholds.global, globalResults.toJSON())
+
+    eachTrackedFiles.forEach(function (key) {
+      var keyThreshold = helper.merge(thresholds.each, overrideThresholds(key, thresholds.each.overrides))
+      check('per-file' + ' (' + key + ') ', keyThreshold, eachResults[key].toJSON())
+    })
+
+    return coverageFailed
+  }
+
+  // Generate the output path from the `coverageReporter.dir` and
+  // `coverageReporter.subdir` options.
+  function generateOutputPath (basePath, browserName, dir = 'coverage', subdir) {
+    if (subdir && typeof subdir === 'function') {
+      subdir = subdir(browserName)
+    }
+    if (browserName) {
+      browserName = browserName.replace(':', '')
+    }
+
+    let outPutPath = path.join(dir, subdir || browserName)
+    outPutPath = path.resolve(basePath, outPutPath)
+
+    return helper.normalizeWinPath(outPutPath)
+  }
+
+  this.onRunStart = function (browsers) {
+    coverageMaps = Object.create(null)
+
+    // TODO(vojta): remove once we don't care about Karma 0.10
+    if (browsers) {
+      browsers.forEach(this.onBrowserStart.bind(this))
+    }
+  }
+
+  this.onBrowserStart = function (browser) {
+    var startingMap = {}
+    if (includeAllSources) {
+      startingMap = globalCoverageMap.get()
+    }
+
+    coverageMaps[browser.id] = istanbulLibCoverage.createCoverageMap(startingMap)
+  }
+
+  this.onBrowserComplete = function (browser, result) {
+    var coverageMap = coverageMaps[browser.id]
+
+    if (!coverageMap) return
+    if (!result || !result.coverage) return
+
+    coverageMap.merge(result.coverage)
+  }
+
+  this.onSpecComplete = function (browser, result) {
+    var coverageMap = coverageMaps[browser.id]
+
+    if (!coverageMap) return
+    if (!result.coverage) return
+
+    coverageMap.merge(result.coverage)
+  }
+
+  let checkedCoverage = {}
+  let promiseComplete = null
+
+  this.executeReport = async function (reporterConfig, browser) {
+    const results = { exitCode: 0 }
+    const coverageMap = coverageMaps[browser.id]
+    if (!coverageMap) {
+      return
+    }
+
+    const mainDir = reporterConfig.dir || config.dir
+    const subDir = reporterConfig.subdir || config.subdir
+    const outputPath = generateOutputPath(basePath, browser.name, mainDir, subDir)
+    const remappedCoverageMap = await sourceMapStore.transformCoverage(coverageMap)
+
+    const options = helper.merge(config, reporterConfig, {
+      dir: outputPath,
+      subdir: '',
+      browser: browser,
+      emitter: emitter,
+      coverageMap: remappedCoverageMap
+    })
+
+    // If config.check is defined, check coverage levels for each browser
+    if (hasOwnProperty.call(config, 'check') && !checkedCoverage[browser.id]) {
+      checkedCoverage[browser.id] = true
+      var coverageFailed = checkCoverage(browser, remappedCoverageMap)
+      if (coverageFailed && results) {
+        results.exitCode = 1
+      }
+    }
+
+    const context = istanbulLibReport.createContext(options)
+    const report = reports.create(reporterConfig.type || 'html', options)
+
+    // // If reporting to console or in-memory skip directory creation
+    const toDisk = !reporterConfig.type || !reporterConfig.type.match(/^(text|text-summary|in-memory)$/)
+
+    if (!toDisk && reporterConfig.file === undefined) {
+      report.execute(context)
+      return results
+    }
+
+    const mkdirIfNotExists = promisify(helper.mkdirIfNotExists)
+    await mkdirIfNotExists(outputPath)
+
+    log.debug('Writing coverage to %s', outputPath)
+    report.execute(context)
+
+    return results
+  }
+
+  this.onRunComplete = function (browsers) {
+    checkedCoverage = {}
+    let results = { exitCode: 0 }
+
+    const promiseCollection = reporters.map(reporterConfig =>
+      Promise.all(browsers.map(async (browser) => {
+        const res = await this.executeReport(reporterConfig, browser)
+        if (res && res.exitCode === 1) {
+          results = res
+        }
+      })))
+    promiseComplete = Promise.all(promiseCollection).then(() => results)
+    return promiseComplete
+  }
+
+  this.onExit = async function (done) {
+    try {
+      const results = await promiseComplete
+      if (results && results.exitCode === 1) {
+        done(results.exitCode)
+        return
+      }
+      if (typeof config._onExit === 'function') {
+        config._onExit(done)
+      } else {
+        done()
+      }
+    } catch (e) {
+      log.error('Unexpected error while generating coverage report.\n', e)
+      done(1)
+    }
+  }
+}
+
+CoverageReporter.$inject = ['config', 'helper', 'logger', 'emitter']
+
+// PUBLISH
+module.exports = CoverageReporter

my-app/node_modules/karma-coverage/lib/source-map-store.js

@@ -0,0 +1,14 @@
+var istanbulLibSourceMaps = require('istanbul-lib-source-maps')
+
+var cache = {}
+
+function get (basePath, opts) {
+  if (!cache[basePath]) {
+    cache[basePath] = istanbulLibSourceMaps.createSourceMapStore(opts)
+  }
+  return cache[basePath]
+}
+
+module.exports = {
+  get: get
+}