monocart-coverage-reports 1.1.0 → 2.0.1

package/lib/platform/share.js

@@ -194,7 +194,7 @@ const Util = {
         return 'high';
     },
 
-    isJsonType(contentType) {
+    isJsonType: (contentType) => {
         if (contentType) {
             if (contentType === 'application/json' || contentType === 'json') {
                 return true;
@@ -203,7 +203,7 @@ const Util = {
         return false;
     },
 
-    isMarkdownType(contentType) {
+    isMarkdownType: (contentType) => {
         if (contentType) {
             if (contentType === 'text/markdown' || contentType === 'markdown') {
                 return true;
@@ -212,7 +212,7 @@ const Util = {
         return false;
     },
 
-    isTextType(contentType) {
+    isTextType: (contentType) => {
         if (contentType) {
             if (contentType.startsWith('text')) {
                 return true;
@@ -227,6 +227,107 @@ const Util = {
         return false;
     },
 
+    isBlank: (codeStr) => {
+        const blankBlock = /\S/;
+        return !blankBlock.test(codeStr);
+    },
+
+    getRangeLines: (sLoc, eLoc) => {
+
+        const lines = [];
+
+        // invalid location order
+        if (sLoc.line > eLoc.line) {
+            return lines;
+        }
+
+        // nothing middle
+        if (sLoc.line === eLoc.line && sLoc.column >= eLoc.column) {
+            return lines;
+        }
+
+        const addStart = () => {
+
+            // nothing start
+            if (sLoc.column >= sLoc.length) {
+                return;
+            }
+
+            const entire = sLoc.column <= sLoc.indent;
+            lines.push({
+                line: sLoc.line,
+                entire,
+                range: {
+                    start: sLoc.column,
+                    end: sLoc.length
+                }
+            });
+        };
+
+        const addMiddle = () => {
+
+            const start = sLoc.column <= sLoc.indent;
+            const end = Util.isBlank(eLoc.text.slice(eLoc.column));
+            const entire = start && end;
+            // same line
+            lines.push({
+                line: sLoc.line,
+                entire,
+                range: {
+                    start: sLoc.column,
+                    end: eLoc.column
+                }
+            });
+        };
+
+        const addEnd = () => {
+
+            // nothing end
+            if (eLoc.column === 0) {
+                return;
+            }
+
+            const entire = Util.isBlank(eLoc.text.slice(eLoc.column));
+            lines.push({
+                line: eLoc.line,
+                entire,
+                range: {
+                    start: eLoc.indent,
+                    end: eLoc.column
+                }
+            });
+        };
+
+        // same line, single line
+        if (sLoc.line === eLoc.line) {
+
+            addMiddle();
+
+        } else {
+            // multiple lines
+
+            addStart();
+
+            // always entire for middle lines
+            const lineStart = sLoc.line + 1;
+            const lineEnd = eLoc.line;
+            if (lineEnd > lineStart) {
+                for (let i = lineStart; i < lineEnd; i++) {
+                    lines.push({
+                        line: i,
+                        entire: true
+                        // no range for entire line
+                    });
+                }
+            }
+
+            // check end
+            addEnd();
+        }
+
+        return lines;
+    },
+
     // =============================================================================
     // svg
 

package/lib/{converter → utils}/source-path.js

@@ -1,5 +1,5 @@
 const path = require('path');
-const Util = require('../utils/util.js');
+const Util = require('./util.js');
 
 const resolveUrl = (input) => {
     let url;
@@ -59,7 +59,7 @@ const getSourcePath = (url, index = '', type = '') => {
 
 const getSourceType = (sourcePath) => {
     let ext = path.extname(sourcePath);
-    let type = '';
+    let type = 'js';
     if (ext) {
         ext = ext.slice(1);
         const reg = /^[a-z0-9]+$/;

package/lib/utils/util.js

@@ -8,6 +8,8 @@ const CG = require('console-grid');
 const Share = require('../platform/share.js');
 const { deflateSync } = require('lz-utils');
 
+const { acornWalk } = require('../packages/monocart-coverage-vendor.js');
+
 const Util = {
 
     root: process.cwd(),
@@ -216,6 +218,31 @@ const Util = {
         return '\n';
     },
 
+    visitAst: (rootNode, visitors) => {
+        const baseVisitor = acornWalk.base;
+        const parents = [rootNode];
+        const visitor = (node, st, override) => {
+            const type = override || node.type;
+            // console.log('visit', node.type, override, parents.length);
+            const handler = visitors[type];
+            if (handler) {
+                const res = handler(node, parents);
+                if (res === 'break') {
+                    return;
+                }
+            }
+            const isNew = node !== parents[parents.length - 1];
+            if (isNew) {
+                parents.push(node);
+            }
+            baseVisitor[type](node, st, visitor);
+            if (isNew) {
+                parents.pop();
+            }
+        };
+        visitor(rootNode);
+    },
+
     forEachFile: function(dir, extList, callback) {
         if (!fs.existsSync(dir)) {
             return;

package/lib/v8/v8-summary.js

@@ -1,44 +1,41 @@
 // https://playwright.dev/docs/api/class-coverage
 
 // url, text, ranges: [ {start, end} ]
-const getCssSummary = (item) => {
+const getCssSummaryBytes = (item) => {
 
     const source = item.source;
     const total = source.length;
 
     let covered = 0;
-    const ranges = item.ranges;
-    if (ranges) {
-        ranges.forEach((range) => {
-            covered += range.end - range.start;
+    const bytes = item.data.bytes;
+    if (bytes) {
+        bytes.forEach((range) => {
+            if (range.count > 0) {
+                covered += range.end - range.start;
+            }
         });
     }
 
-    const uncovered = total - covered;
-
+    // no functions for css
     return {
-        name: item.sourcePath,
-        type: item.type,
-        url: item.url,
         total,
-        covered,
-        uncovered
+        covered
     };
 
 };
 
 // url, source, ranges:[{start,end, count}]
-const getJsSummary = (item) => {
+const getJsSummaryBytes = (item) => {
 
     const source = item.source;
     const total = source.length;
 
-    const uncoveredRanges = item.ranges.filter((range) => range.count === 0);
+    const uncoveredBytes = item.data.bytes.filter((range) => range.count === 0);
 
     let uncovered = 0;
 
     let endPos = 0;
-    uncoveredRanges.forEach((range) => {
+    uncoveredBytes.forEach((range) => {
         const { start, end } = range;
 
         if (start > endPos) {
@@ -58,23 +55,21 @@ const getJsSummary = (item) => {
 
     const covered = total - uncovered;
 
+    // console.log(item)
+
     return {
-        name: item.sourcePath,
-        type: item.type,
-        url: item.url,
         total,
-        covered,
-        uncovered
+        covered
     };
 };
 
-const getV8Summary = (item) => {
+const getV8SummaryBytes = (item) => {
     if (item.type === 'css') {
-        return getCssSummary(item);
+        return getCssSummaryBytes(item);
     }
-    return getJsSummary(item);
+    return getJsSummaryBytes(item);
 };
 
 module.exports = {
-    getV8Summary
+    getV8SummaryBytes
 };

package/lib/v8/v8.js

@@ -1,10 +1,11 @@
 const path = require('path');
 const Util = require('../utils/util.js');
-const { getV8Summary } = require('./v8-summary.js');
-const { dedupeRanges } = require('../converter/dedupe.js');
-const { getSourcePath } = require('../converter/source-path.js');
+const { getV8SummaryBytes } = require('./v8-summary.js');
+const { dedupeRanges } = require('../utils/dedupe.js');
+const { getSourcePath } = require('../utils/source-path.js');
 const { mergeScriptCovs } = require('../packages/monocart-coverage-vendor.js');
 const collectSourceMaps = require('../converter/collect-source-maps.js');
+const version = require('../../package.json').version;
 
 const initV8ListAndSourcemap = async (v8list, options, inlineSourceMap) => {
 
@@ -73,6 +74,7 @@ const initV8ListAndSourcemap = async (v8list, options, inlineSourceMap) => {
     const time_start = Date.now();
     const count = await collectSourceMaps(v8list, options, inlineSourceMap);
     if (count) {
+        // debug level time
         Util.logTime(`loaded ${count} sourcemaps`, time_start);
     }
 
@@ -227,48 +229,84 @@ const saveV8HtmlReport = async (reportData, options, v8HtmlOptions) => {
     return htmlPath;
 };
 
+// calculate uncovered, pct, status
+const calculatePctAndStatus = (item, watermarks) => {
+    Object.keys(item).forEach((k) => {
+        const indicateData = item[k];
+        indicateData.uncovered = indicateData.total - indicateData.covered;
+
+        let pct = '';
+        let status = 'unknown';
+
+        if (indicateData.total) {
+            pct = Util.PNF(indicateData.covered, indicateData.total, 2);
+            status = Util.getStatus(pct, watermarks[k]);
+        }
+
+        indicateData.pct = pct;
+        indicateData.status = status;
+
+    });
+};
+
 const saveV8Report = async (v8list, options) => {
     const defaultWatermarks = {
-        bytes: [50, 80]
+        bytes: [50, 80],
+        functions: [50, 80],
+        branches: [50, 80],
+        lines: [50, 80]
     };
     const watermarks = Util.resolveWatermarks(defaultWatermarks, options.watermarks);
 
-    const bytesWatermarks = watermarks.bytes;
-
     // init summary
     v8list.forEach((entry) => {
-        entry.summary = getV8Summary(entry);
+        entry.summary.bytes = getV8SummaryBytes(entry);
     });
 
-    // calculate pct, status and summary
+    // overall summary
     const summaryList = v8list.map((entry) => entry.summary);
-    let total = 0;
-    let covered = 0;
+    const summary = {
+        bytes: {
+            total: 0,
+            covered: 0
+        },
+        functions: {
+            total: 0,
+            covered: 0
+        },
+        branches: {
+            total: 0,
+            covered: 0
+        },
+        lines: {
+            total: 0,
+            covered: 0,
+            blank: 0,
+            comment: 0
+        }
+    };
     summaryList.forEach((item) => {
+        calculatePctAndStatus(item, watermarks);
+        Object.keys(item).forEach((k) => {
+            const indicateData = item[k];
+            if (!indicateData) {
+                return;
+            }
+            summary[k].total += indicateData.total;
+            summary[k].covered += indicateData.covered;
 
-        total += item.total;
-        covered += item.covered;
-
-        item.pct = Util.PNF(item.covered, item.total, 2);
-        item.status = Util.getStatus(item.pct, bytesWatermarks);
-
+            if (k === 'lines') {
+                summary[k].blank += indicateData.blank;
+                summary[k].comment += indicateData.comment;
+            }
+        });
     });
 
-    const uncovered = total - covered;
-
-    const pct = Util.PNF(covered, total, 2);
-    const status = Util.getStatus(pct, bytesWatermarks);
-
-    const summary = {
-        total,
-        covered,
-        uncovered,
-        pct,
-        status
-    };
+    calculatePctAndStatus(summary, watermarks);
 
     const reportData = {
         name: options.name,
+        version,
         watermarks,
         summary,
         files: v8list

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "monocart-coverage-reports",
-    "version": "1.1.0",
+    "version": "2.0.1",
     "description": "Monocart coverage reports",
     "main": "lib/index.js",
     "exports": {
@@ -14,17 +14,20 @@
     },
     "types": "./lib/index.d.ts",
     "scripts": {
-        "build-test": "npm run build-istanbul && npm run build-v8",
-        "build-istanbul": "npx webpack --config mock/webpack.config-istanbul.js",
-        "build-v8": "npx webpack --config mock/webpack.config-v8.js",
-        "test": "node ./tests/test.js && npm run build-docs",
-        "build": "sf lint && sf b -p && npm run build-docs",
-        "dev": "sf d v8",
         "build-docs": "node ./scripts/build-docs.js",
+        "build-test": "node ./scripts/build-test.js",
+        "build": "sf lint && sf b -p && npm run build-test",
+        "test-node": "npm run test-node-env && npm run test-node-ins",
+        "test-node-env": "cross-env NODE_V8_COVERAGE=.temp/v8-coverage node ./test/test-node-env.js && node ./test/generate-node-report.js",
+        "test-node-ins": "node ./test/test-node-ins.js",
+        "test-browser": "node ./test/test.js",
+        "test": "npm run test-browser && npm run test-node && npm run build-docs",
+        "dev": "sf d v8",
         "patch": "npm run build && sf publish patch -r"
     },
     "workspaces": [
-        "packages/*"
+        "packages/*",
+        "test"
     ],
     "files": [
         "lib"
@@ -35,31 +38,23 @@
         "url": "git+https://github.com/cenfun/monocart-coverage-reports.git"
     },
     "dependencies": {
-        "console-grid": "^2.0.1",
-        "eight-colors": "^1.0.3",
-        "istanbul-lib-coverage": "^3.2.2",
-        "istanbul-lib-report": "^3.0.1",
-        "istanbul-reports": "^3.1.6",
-        "lz-utils": "^2.0.1",
-        "monocart-code-viewer": "^1.0.8",
-        "monocart-formatter": "^1.0.7",
-        "turbogrid": "^3.0.10"
+        "console-grid": "~2.0.1",
+        "eight-colors": "~1.0.3",
+        "istanbul-lib-coverage": "~3.2.2",
+        "istanbul-lib-report": "~3.0.1",
+        "istanbul-reports": "~3.1.6",
+        "lz-utils": "~2.0.1",
+        "monocart-code-viewer": "^1.0.12",
+        "monocart-formatter": "~2.2.0",
+        "turbogrid": "~3.0.12"
     },
     "devDependencies": {
-        "babel-loader": "^9.1.3",
-        "babel-plugin-istanbul": "^6.1.1",
-        "eslint": "^8.55.0",
+        "cross-env": "^7.0.3",
+        "eslint": "^8.56.0",
         "eslint-config-plus": "^1.0.6",
         "eslint-plugin-html": "^7.1.0",
         "eslint-plugin-vue": "^9.19.2",
-        "github-markdown-css": "^5.5.0",
-        "koa": "^2.14.2",
-        "koa-static-resolver": "^1.0.4",
-        "marked": "^11.1.0",
-        "playwright": "^1.40.1",
-        "stylelint": "^16.0.2",
-        "stylelint-config-plus": "^1.0.4",
-        "webpack": "^5.89.0",
-        "webpack-cli": "^5.1.4"
+        "stylelint": "^15.11.0",
+        "stylelint-config-plus": "^1.0.4"
     }
 }

package/lib/converter/position-mapping.js

@@ -1,183 +0,0 @@
-
-const findLine = function(list, position) {
-    let start = 0;
-    let end = list.length - 1;
-    while (end - start > 1) {
-        const i = Math.floor((start + end) * 0.5);
-        const item = list[i];
-        if (position < item.start) {
-            end = i;
-            continue;
-        }
-        if (position > item.end) {
-            start = i;
-            continue;
-        }
-        return list[i];
-    }
-    // last two items, less is start
-    const endItem = list[end];
-    if (position < endItem.start) {
-        return list[start];
-    }
-    return list[end];
-};
-
-// =======================================================================================
-
-const isLineSingleCommented = (codeStr) => {
-    const singleBlock = /^\s*\/\//g;
-    return singleBlock.test(codeStr);
-};
-
-const isLineStartCommented = (codeStr) => {
-    const multiStartBlock = /^\s*\/\*/g;
-    return multiStartBlock.test(codeStr);
-};
-
-// multi-comment end but not at end
-const isLineEndCommented = (codeStr) => {
-    const multiEndBlock = /.*\*\//g;
-    return multiEndBlock.test(codeStr);
-};
-
-const isLineEndCommentedToEnd = (codeStr) => {
-    const multiEndBlock = /.*\*\/\s*$/g;
-    return multiEndBlock.test(codeStr);
-};
-
-const isLineBlank = (codeStr) => {
-    const blankBlock = /\S/;
-    return !blankBlock.test(codeStr);
-};
-
-class PositionMapping {
-    constructor(source) {
-        this.source = source;
-        this.lines = this.buildLines(source);
-        this.commentedLines = [];
-        this.blankLines = [];
-        this.parseLines(this.lines);
-    }
-
-    // =============================================================================
-
-    getSlice(s, e) {
-        return this.source.slice(s, e);
-    }
-
-    // 1-base
-    locationToOffset(location) {
-        const { line, column } = location;
-        // 1-based
-        const lineInfo = this.lines[line - 1];
-        if (lineInfo) {
-            if (column === Infinity) {
-                return lineInfo.start + lineInfo.length;
-            }
-            return lineInfo.start + column;
-        }
-        return 0;
-    }
-
-    // 1-base
-    offsetToLocation(offset) {
-        const lineInfo = findLine(this.lines, offset);
-
-        let indent = lineInfo.text.search(/\S/);
-        if (indent === -1) {
-            indent = lineInfo.length;
-        }
-
-        // 1-base
-        const line = lineInfo.line + 1;
-        const column = Math.min(Math.max(offset - lineInfo.start, 0), lineInfo.length);
-
-        return {
-            ... lineInfo,
-            line,
-            column,
-            indent
-        };
-    }
-
-    // 1-base
-    getLine(line) {
-        return this.lines[line - 1];
-    }
-
-    // =============================================================================
-
-    buildLines(content) {
-        let pos = 0;
-        const lines = content.split(/\n/).map((text, line) => {
-
-            let n = 1;
-            // may ends with \r (don't consider double \r\r for now)
-            const reg = /\r$/;
-            if (reg.test(text)) {
-                text = text.slice(0, -1);
-                n += 1;
-            }
-
-            const length = text.length;
-            const start = pos;
-            const end = start + length;
-
-            pos += length + n;
-
-            return {
-                line,
-                start,
-                end,
-                length,
-                text
-            };
-        });
-
-        return lines;
-    }
-
-    parseLines(lines) {
-        const commentedLines = [];
-        const blankLines = [];
-
-        let startCommented = false;
-
-        const multiEndHandler = (text, i) => {
-            if (isLineEndCommented(text)) {
-                startCommented = false;
-                if (isLineEndCommentedToEnd(text)) {
-                    commentedLines.push(i);
-                }
-                return;
-            }
-            commentedLines.push(i);
-        };
-
-        lines.forEach((line, i) => {
-            const text = line.text;
-            if (startCommented) {
-                return multiEndHandler(text, i);
-            }
-            if (isLineStartCommented(text)) {
-                startCommented = true;
-                return multiEndHandler(text, i);
-            }
-            if (isLineSingleCommented(text)) {
-                commentedLines.push(i);
-                return;
-            }
-            if (isLineBlank(text)) {
-                blankLines.push(i);
-            }
-        });
-
-        this.commentedLines = commentedLines;
-        this.blankLines = blankLines;
-    }
-
-}
-
-module.exports = PositionMapping;
-