monocart-coverage-reports 2.9.2 → 2.10.0

package/lib/converter/flatten-source-maps.js

@@ -1,166 +1,186 @@
-const { decode } = require('@jridgewell/sourcemap-codec');
-
-function getLine(arr, index) {
-    for (let i = arr.length; i <= index; i++) {
-        arr[i] = [];
-    }
-    return arr[index];
-}
-
-function addMappings(options, sourcesOffset) {
-
-    const {
-        input,
-        lineOffset,
-        columnOffset,
-        stopLine,
-        stopColumn
-    } = options;
-
-    const decoded = decode(input.mappings);
-    const COLUMN = 0;
-    const SOURCES_INDEX = 1;
-    const SOURCE_LINE = 2;
-    const SOURCE_COLUMN = 3;
-
-    for (let i = 0; i < decoded.length; i++) {
-        const lineI = lineOffset + i;
-
-        if (lineI > stopLine) {
-            return;
-        }
-
-        const out = getLine(options.decodedMappings, lineI);
-        const cOffset = i === 0 ? columnOffset : 0;
-
-        const line = decoded[i];
-        for (let j = 0; j < line.length; j++) {
-            const seg = line[j];
-            const column = cOffset + seg[COLUMN];
-
-            if (lineI === stopLine && column >= stopColumn) {
-                return;
-            }
-
-            if (seg.length === 1) {
-                out.push([column]);
-                continue;
-            }
-
-            const sourcesIndex = sourcesOffset + seg[SOURCES_INDEX];
-            const sourceLine = seg[SOURCE_LINE];
-            const sourceColumn = seg[SOURCE_COLUMN];
-            out.push([column, sourcesIndex, sourceLine, sourceColumn]);
-        }
-    }
-}
-
-function addSection(options) {
-
-    const { input } = options;
-
-    const { sections } = input;
-    if (sections) {
-        return flatten(options);
-    }
-
-    const sourcesOffset = options.sources.length;
-
-    if (!input.sourcesContent) {
-        input.sourcesContent = [];
-    }
-    input.sources.forEach((src, i) => {
-        options.sources.push(src);
-        options.sourcesContent.push(input.sourcesContent[i] || null);
-    });
-
-    addMappings(options, sourcesOffset);
-
-}
-
-function flatten(options) {
-
-    const {
-        input,
-        lineOffset,
-        columnOffset,
-        stopLine,
-        stopColumn
-    } = options;
-
-    const { sections } = input;
-
-    for (let i = 0, l = sections.length; i < l; i++) {
-        const { map, offset } = sections[i];
-
-        let sl = stopLine;
-        let sc = stopColumn;
-        if (i + 1 < sections.length) {
-            const nextOffset = sections[i + 1].offset;
-            sl = Math.min(stopLine, lineOffset + nextOffset.line);
-
-            if (sl === stopLine) {
-                sc = Math.min(stopColumn, columnOffset + nextOffset.column);
-            } else if (sl < stopLine) {
-                sc = columnOffset + nextOffset.column;
-            }
-        }
-
-        options.input = map;
-        options.lineOffset = lineOffset + offset.line;
-        options.columnOffset = columnOffset + offset.column;
-        options.stopLine = sl;
-        options.stopColumn = sc;
-
-        addSection(options);
-    }
-}
-
-const flattenSourceMaps = function(indexedMap, mapUrl) {
-
-    const sections = indexedMap.sections;
-    if (!sections) {
-        return indexedMap;
-    }
-
-    const decodedMappings = [];
-    const sources = [];
-    const sourcesContent = [];
-    const names = [];
-    const ignoreList = [];
-
-    const lineOffset = 0;
-    const columnOffset = 0;
-    const stopLine = Infinity;
-    const stopColumn = Infinity;
-
-    flatten({
-        input: indexedMap,
-
-        mapUrl,
-
-        decodedMappings,
-        sources,
-        sourcesContent,
-
-        names,
-        ignoreList,
-
-        lineOffset,
-        columnOffset,
-        stopLine,
-        stopColumn
-    });
-
-    indexedMap.sources = sources;
-    indexedMap.sourcesContent = sourcesContent;
-    indexedMap.decodedMappings = decodedMappings;
-
-    // console.log(decodedMappings);
-
-    return indexedMap;
-};
-
-module.exports = {
-    flattenSourceMaps
-};
+const { decode } = require('@jridgewell/sourcemap-codec');
+
+const COLUMN = 0;
+const SOURCES_INDEX = 1;
+const SOURCE_LINE = 2;
+const SOURCE_COLUMN = 3;
+const NAMES_INDEX = 4;
+
+function getLine(arr, index) {
+    for (let i = arr.length; i <= index; i++) {
+        arr[i] = [];
+    }
+    return arr[index];
+}
+
+function getMapping(seg, column, sourcesOffset, namesOffset) {
+
+    const sourcesIndex = sourcesOffset + seg[SOURCES_INDEX];
+    const sourceLine = seg[SOURCE_LINE];
+    const sourceColumn = seg[SOURCE_COLUMN];
+
+    if (seg.length === 4) {
+        return [column, sourcesIndex, sourceLine, sourceColumn];
+    }
+
+    return [column, sourcesIndex, sourceLine, sourceColumn, namesOffset + seg[NAMES_INDEX]];
+}
+
+function addMappings(options, sourcesOffset, namesOffset) {
+
+    const {
+        input,
+        lineOffset,
+        columnOffset,
+        stopLine,
+        stopColumn
+    } = options;
+
+    const decoded = decode(input.mappings);
+
+    for (let i = 0; i < decoded.length; i++) {
+        const lineI = lineOffset + i;
+
+        if (lineI > stopLine) {
+            return;
+        }
+
+        const out = getLine(options.decodedMappings, lineI);
+        const cOffset = i === 0 ? columnOffset : 0;
+
+        const line = decoded[i];
+        for (let j = 0; j < line.length; j++) {
+            const seg = line[j];
+            const column = cOffset + seg[COLUMN];
+
+            if (lineI === stopLine && column >= stopColumn) {
+                return;
+            }
+
+            if (seg.length === 1) {
+                out.push([column]);
+                continue;
+            }
+
+            out.push(getMapping(seg, column, sourcesOffset, namesOffset));
+        }
+    }
+}
+
+function addSection(options) {
+
+    const { input } = options;
+
+    const { sections } = input;
+    if (sections) {
+        return flatten(options);
+    }
+
+    const sourcesOffset = options.sources.length;
+    const namesOffset = options.names.length;
+
+    // sources and sourcesContent
+    if (!input.sourcesContent) {
+        input.sourcesContent = [];
+    }
+    input.sources.forEach((src, i) => {
+        options.sources.push(src);
+        options.sourcesContent.push(input.sourcesContent[i] || null);
+    });
+
+    // names
+    if (input.names) {
+        input.names.forEach((n) => {
+            options.names.push(n);
+        });
+    }
+
+    addMappings(options, sourcesOffset, namesOffset);
+
+}
+
+function flatten(options) {
+
+    const {
+        input,
+        lineOffset,
+        columnOffset,
+        stopLine,
+        stopColumn
+    } = options;
+
+    const { sections } = input;
+
+    for (let i = 0, l = sections.length; i < l; i++) {
+        const { map, offset } = sections[i];
+
+        let sl = stopLine;
+        let sc = stopColumn;
+        if (i + 1 < sections.length) {
+            const nextOffset = sections[i + 1].offset;
+            sl = Math.min(stopLine, lineOffset + nextOffset.line);
+
+            if (sl === stopLine) {
+                sc = Math.min(stopColumn, columnOffset + nextOffset.column);
+            } else if (sl < stopLine) {
+                sc = columnOffset + nextOffset.column;
+            }
+        }
+
+        options.input = map;
+        options.lineOffset = lineOffset + offset.line;
+        options.columnOffset = columnOffset + offset.column;
+        options.stopLine = sl;
+        options.stopColumn = sc;
+
+        addSection(options);
+    }
+}
+
+const flattenSourceMaps = function(indexedMap, mapUrl) {
+
+    const sections = indexedMap.sections;
+    if (!sections) {
+        return indexedMap;
+    }
+
+    const decodedMappings = [];
+    const sources = [];
+    const sourcesContent = [];
+    const names = [];
+
+    const lineOffset = 0;
+    const columnOffset = 0;
+    const stopLine = Infinity;
+    const stopColumn = Infinity;
+
+    flatten({
+        input: indexedMap,
+
+        mapUrl,
+
+        decodedMappings,
+        sources,
+        sourcesContent,
+
+        names,
+
+        lineOffset,
+        columnOffset,
+        stopLine,
+        stopColumn
+    });
+
+    indexedMap.sources = sources;
+    indexedMap.sourcesContent = sourcesContent;
+    indexedMap.names = names;
+    indexedMap.decodedMappings = decodedMappings;
+
+    // console.log(decodedMappings);
+
+    return indexedMap;
+};
+
+module.exports = {
+    flattenSourceMaps
+};

package/lib/converter/ignore.js

@@ -69,16 +69,77 @@ const addNextIgnore = (list, content, item, locator) => {
 };
 
 // both v8 or c8
-const hasIgnoreKey = (content) => {
-    const v8Key = 'v8 ignore';
-    if (content.startsWith(v8Key)) {
-        return v8Key.length;
+const getStartEndNextInfo = (content) => {
+    content = content.trim();
+
+    const start = 'start';
+    const stop = 'stop';
+    const next = 'next';
+    if (content.startsWith(start)) {
+        return {
+            type: 'range',
+            value: stop
+        };
     }
-    const c8Key = 'c8 ignore';
-    if (content.startsWith(c8Key)) {
-        return c8Key.length;
+    if (content.startsWith(stop)) {
+        return {
+            type: 'range',
+            value: stop
+        };
+    }
+    if (content.startsWith(next)) {
+        return {
+            type: 'next',
+            value: content.slice(next.length)
+        };
+    }
+};
+
+const getDisableEnableNextInfo = (content) => {
+    content = content.trim();
+
+    const start = 'disable';
+    const stop = 'enable';
+    const next = 'ignore next';
+    if (content.startsWith(start)) {
+        return {
+            type: 'range',
+            value: stop
+        };
+    }
+    if (content.startsWith(stop)) {
+        return {
+            type: 'range',
+            value: stop
+        };
+    }
+    if (content.startsWith(next)) {
+        return {
+            type: 'next',
+            value: content.slice(next.length)
+        };
     }
-    // istanbul ignore has different rules, can not support it
+};
+
+
+const getIgnoreInfo = (content) => {
+    content = content.trim();
+
+    const v8_ignore = 'v8 ignore';
+    if (content.startsWith(v8_ignore)) {
+        return getStartEndNextInfo(content.slice(v8_ignore.length));
+    }
+
+    const c8_ignore = 'c8 ignore';
+    if (content.startsWith(c8_ignore)) {
+        return getStartEndNextInfo(content.slice(c8_ignore.length));
+    }
+
+    const node_coverage = 'node:coverage';
+    if (content.startsWith(node_coverage)) {
+        return getDisableEnableNextInfo(content.slice(node_coverage.length));
+    }
+
 };
 
 const getIgnoredRanges = (locator, options) => {
@@ -101,42 +162,43 @@ const getIgnoredRanges = (locator, options) => {
         const {
             block, start, end, text
         } = item;
-        let content = block ? text.slice(2, -2) : text.slice(2);
-        content = content.trim();
 
-        const ignoreKey = hasIgnoreKey(content);
-        if (!ignoreKey) {
+        const content = block ? text.slice(2, -2) : text.slice(2);
+        const ignoreInfo = getIgnoreInfo(content);
+        if (!ignoreInfo) {
             return;
         }
 
-        content = content.slice(ignoreKey).trim();
+        const { type, value } = ignoreInfo;
 
         if (ignoreStart) {
             // v-8 ignore stop
-            if (content === 'stop') {
-                ignoreStart.end = extendEnd(end, source, maxLength);
+            if (type === 'range' && value === ignoreStart.value) {
+                ignoreStart.ignoreData.end = extendEnd(end, source, maxLength);
                 ignoreStart = null;
             }
             return;
         }
 
         // v-8 ignore start
-        if (content === 'start') {
+        if (type === 'range') {
             // add first for sort by start
-            ignoreStart = {
-                type: 'start-stop',
+            const ignoreData = {
+                type,
                 start: extendStart(start, source),
                 end: start
             };
-            list.push(ignoreStart);
+            list.push(ignoreData);
+            ignoreStart = {
+                ignoreData,
+                value
+            };
             return;
         }
 
-        // v-8 ignore next N
-        const nextKey = 'next';
-        if (content.startsWith(nextKey)) {
-            content = content.slice(nextKey.length).trim();
-            addNextIgnore(list, content, item, locator);
+        // next N
+        if (type === 'next') {
+            addNextIgnore(list, value.trim(), item, locator);
         }
 
     });

package/lib/converter/info-function.js

@@ -16,8 +16,13 @@ module.exports = class InfoFunction {
         this.original = original;
     }
 
-    getRange() {
+    getName(index) {
+        return this.functionName || `(anonymous_${index})`;
+    }
+
+    getRange(index) {
         const range = {
+            name: this.getName(index),
             start: this.start,
             end: this.end,
             count: this.count
@@ -51,10 +56,8 @@ module.exports = class InfoFunction {
 
         const line = loc.start.line;
 
-        const functionName = this.functionName || `(anonymous_${index})`;
-
         return {
-            name: functionName,
+            name: this.getName(index),
             decl: decl,
             loc: loc,
             line: line