monocart-reporter 1.7.1 → 1.7.2

package/lib/utils/util.js

@@ -4,9 +4,12 @@ const path = require('path');
 const os = require('os');
 const crypto = require('crypto');
 const EC = require('eight-colors');
+const CG = require('console-grid');
 const Share = require('../platform/share.js');
 const { deflateSync } = require('lz-utils');
 
+const assetsName = 'assets';
+
 const Util = {
 
     root: process.cwd(),
@@ -116,6 +119,23 @@ const Util = {
         return sourcePath;
     },
 
+    // empty or create dir
+    initDir: (dirPath) => {
+        if (fs.existsSync(dirPath)) {
+            Util.rmSync(dirPath);
+        }
+        fs.mkdirSync(dirPath, {
+            recursive: true
+        });
+    },
+
+    initAssetsDir: async (options) => {
+        const outputFile = await Util.resolveOutputFile(options.outputFile);
+        const outputDir = path.dirname(outputFile);
+        const assetsDir = path.resolve(outputDir, assetsName);
+        Util.initDir(assetsDir);
+    },
+
     saveHtmlReport: async (options) => {
 
         const {
@@ -127,7 +147,6 @@ const Util = {
 
             outputDir,
             reportDataFile,
-            assetsName,
             assetsRelative
         } = options;
 
@@ -226,7 +245,7 @@ const Util = {
     writeJSONSync: function(filePath, json) {
         let content = Util.jsonString(json);
         if (!content) {
-            EC.logRed('[MCR] invalid JSON object');
+            Util.logError('invalid JSON object');
             return false;
         }
         // end of line
@@ -325,7 +344,7 @@ const Util = {
             if (template) {
                 Util.templateCache[templatePath] = template;
             } else {
-                EC.logRed(`[MCR] not found template: ${templatePath}`);
+                Util.logError(`not found template: ${templatePath}`);
             }
         }
         return template;
@@ -352,6 +371,81 @@ const Util = {
             });
         });
         return option;
+    },
+
+    // ==========================================================================================
+
+    loggingLevels: {
+        off: 0,
+        error: 10,
+        info: 20,
+        debug: 30
+    },
+
+    initLoggingLevel: (level, from = '') => {
+        if (!level && Util.loggingType) {
+            return;
+        }
+        const types = {
+            off: 'off',
+            error: 'error',
+            info: 'info',
+            debug: 'debug'
+        };
+        const type = types[level] || types.info;
+        Util.loggingType = type;
+        Util.loggingLevel = Util.loggingLevels[type];
+
+        // console.log('=========================================');
+        // console.log(from, Util.loggingType, Util.loggingLevel);
+    },
+
+    logError: (message) => {
+        if (Util.loggingLevel < Util.loggingLevels.error) {
+            return;
+        }
+        EC.logRed(`[MCR] ${message}`);
+    },
+
+    logInfo: (message) => {
+        if (Util.loggingLevel < Util.loggingLevels.info) {
+            return;
+        }
+        console.log(`[MCR] ${message}`);
+    },
+
+    // grid is info level
+    logGrid: (gridData) => {
+        if (Util.loggingLevel < Util.loggingLevels.info) {
+            return;
+        }
+        CG(gridData);
+    },
+
+    logDebug: (message) => {
+        if (Util.loggingLevel < Util.loggingLevels.debug) {
+            return;
+        }
+        console.log(`[MCR] ${message}`);
+    },
+
+    // time is debug level
+    logTime: (message, time_start) => {
+        if (Util.loggingLevel < Util.loggingLevels.debug) {
+            return;
+        }
+        const duration = Date.now() - time_start;
+        const durationH = Util.TSF(duration);
+        const ls = [`[MCR] ${message}`, ' ('];
+        if (duration <= 100) {
+            ls.push(EC.green(durationH));
+        } else if (duration < 500) {
+            ls.push(EC.yellow(durationH));
+        } else {
+            ls.push(EC.red(durationH));
+        }
+        ls.push(')');
+        console.log(ls.join(''));
     }
 
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "monocart-reporter",
-    "version": "1.7.1",
+    "version": "1.7.2",
     "description": "A playwright test reporter. Shows suites/cases/steps with tree style, markdown annotations, custom columns/formatters/data collection visitors, console logs, style tags, send email.",
     "main": "lib/index.js",
     "bin": {
@@ -48,8 +48,7 @@
         "koa-static-resolver": "^1.0.4",
         "lz-utils": "^2.0.1",
         "nodemailer": "^6.9.3",
-        "open": "^9.1.0",
-        "source-map": "^0.7.4"
+        "open": "^9.1.0"
     },
     "devDependencies": {
         "@playwright/test": "^1.35.1",
@@ -58,8 +57,8 @@
         "eslint": "^8.43.0",
         "eslint-config-plus": "^1.0.6",
         "eslint-plugin-html": "^7.1.0",
-        "eslint-plugin-vue": "^9.15.0",
-        "stylelint": "^15.8.0",
+        "eslint-plugin-vue": "^9.15.1",
+        "stylelint": "^15.9.0",
         "stylelint-config-plus": "^1.0.3",
         "vine-ui": "^3.1.12"
     }

package/lib/plugins/coverage/v8/position-mapping.js

@@ -1,92 +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];
-};
-
-class PositionMapping {
-    constructor(source, sourceName) {
-        this.source = source;
-        this.sourceName = sourceName;
-        this.lines = this.getLines(source);
-        this.ranges = [];
-    }
-
-    // =============================================================================
-
-    getSlice(s, e) {
-        return this.source.slice(s, e);
-    }
-
-    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;
-    }
-
-    offsetToLocation(offset) {
-        const lineInfo = findLine(this.lines, offset);
-        const column = Math.min(Math.max(offset - lineInfo.start, 0), lineInfo.length);
-
-        // 1-based
-        const line = lineInfo.line + 1;
-
-        return {
-            line,
-            column
-        };
-    }
-
-    // =============================================================================
-
-    getLines(content) {
-        let pos = 0;
-        const lines = content.split(/\n/).map((text, line) => {
-            const length = text.length;
-            const start = pos;
-            const end = start + length;
-
-            pos += length + 1;
-
-            return {
-                line,
-                start,
-                end,
-                length,
-                text
-            };
-        });
-
-        return lines;
-    }
-
-}
-
-module.exports = PositionMapping;
-

package/lib/plugins/coverage/v8/source-map.js

@@ -1,451 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const EC = require('eight-colors');
-
-const { SourceMapConsumer } = require('source-map');
-
-const PositionMapping = require('./position-mapping.js');
-const { dedupeCountRanges } = require('./dedupe.js');
-const { initSourceMapRootAndUrl } = require('../coverage-utils.js');
-
-const Concurrency = require('../../../platform/concurrency.js');
-const { convertSourceMap, axios } = require('../../../runtime/monocart-coverage.js');
-const Util = require('../../../utils/util.js');
-
-// SourceMapConsumer.GREATEST_LOWER_BOUND = 1;
-// SourceMapConsumer.LEAST_UPPER_BOUND = 2;
-const BIAS = {
-    left: SourceMapConsumer.GREATEST_LOWER_BOUND,
-    right: SourceMapConsumer.LEAST_UPPER_BOUND
-};
-
-// =========================================================================================================
-
-const findOriginalPosition = (consumer, line, column, sides) => {
-    let original;
-    for (const side of sides) {
-        original = consumer.originalPositionFor({
-            line,
-            column,
-            bias: BIAS[side]
-        });
-        if (original.source !== null) {
-            break;
-        }
-    }
-    if (original && original.source !== null) {
-        return original;
-    }
-};
-
-const findOriginalStartPosition = (consumer, sLoc) => {
-    const { line, column } = sLoc;
-    return findOriginalPosition(consumer, line, column, ['right', 'left']);
-};
-
-const findOriginalEndInRange = (consumer, generatedMapping, range) => {
-    const { start, end } = range;
-    // from -2 (already -1)
-    // > start (no need equal)
-    for (let i = end - 2; i > start; i--) {
-        const loc = generatedMapping.offsetToLocation(i);
-        const op = findOriginalPosition(consumer, loc.line, loc.column, ['left', 'right']);
-        if (op) {
-            return op;
-        }
-    }
-};
-
-const findOriginalEndPosition = (consumer, eLoc, generatedMapping, range) => {
-    const { line, column } = eLoc;
-
-    // before end column must be >= 0
-    const currentColumn = Math.max(column - 1, 0);
-
-    let ep = findOriginalPosition(consumer, line, currentColumn, ['left', 'right']);
-    if (!ep) {
-        ep = findOriginalEndInRange(consumer, generatedMapping, range);
-        if (!ep) {
-            return;
-        }
-    }
-
-    const afterEndMapping = consumer.generatedPositionFor({
-        source: ep.source,
-        line: ep.line,
-        column: ep.column + 1,
-        bias: BIAS.right
-    });
-
-    if (afterEndMapping.line === null) {
-        return {
-            source: ep.source,
-            line: ep.line,
-            column: Infinity
-        };
-    }
-
-    const mapping = consumer.originalPositionFor(afterEndMapping);
-    if (mapping.line !== ep.line) {
-        return {
-            source: ep.source,
-            line: ep.line,
-            column: Infinity
-        };
-    }
-
-    return mapping;
-};
-
-// =========================================================================================================
-
-const getOriginalMappings = (consumer, options) => {
-
-    // source filter
-    let sourceList = consumer.sources;
-    if (typeof options.sourceFilter === 'function') {
-        sourceList = sourceList.filter((sourceName) => {
-            return options.sourceFilter(sourceName);
-        });
-    }
-
-    // create original content mappings
-    const originalMappings = new Map();
-    for (const sourceName of sourceList) {
-        // console.log(`add source: ${k}`);
-        const sourceContent = consumer.sourceContentFor(sourceName);
-        if (typeof sourceContent !== 'string') {
-            EC.logRed(`[MCR] not found source content: ${sourceName}`);
-            continue;
-        }
-
-        const mapping = new PositionMapping(sourceContent, sourceName);
-        originalMappings.set(sourceName, mapping);
-    }
-
-    return originalMappings;
-};
-
-// =========================================================================================================
-
-const addOriginalRange = (originalMapping, start, end, count) => {
-    originalMapping.ranges.push({
-        start,
-        end,
-        count
-    });
-};
-
-// =========================================================================================================
-
-
-const unpackJsSourceMap = async (item, v8list, options) => {
-    // console.log('------------------------------------------------------');
-    // console.log(item.type, item.url);
-    // console.log(Object.keys(item));
-
-    const sourceMap = item.sourceMap;
-
-    const fileUrls = {};
-    const fileSources = {};
-    initSourceMapRootAndUrl(sourceMap, fileUrls, fileSources);
-
-    const generatedMapping = new PositionMapping(item.source);
-    const consumer = await new SourceMapConsumer(sourceMap);
-    const originalMappings = getOriginalMappings(consumer, options);
-
-    // generated ranges to original ranges
-    item.ranges.forEach((range) => {
-
-        // find start location
-        const sLoc = generatedMapping.offsetToLocation(range.start);
-        const oSLoc = findOriginalStartPosition(consumer, sLoc);
-        if (!oSLoc) {
-            // not found start
-            return;
-        }
-
-        // if source excluded
-        const currentSource = oSLoc.source;
-        const originalMapping = originalMappings.get(currentSource);
-        if (!originalMapping) {
-            // possible this source has been filtered
-            // console.log(`not found source: ${currentSource}`);
-            return;
-        }
-
-        const originalStart = originalMapping.locationToOffset(oSLoc);
-
-        // find end location
-        const eLoc = generatedMapping.offsetToLocation(range.end);
-        const oELoc = findOriginalEndPosition(consumer, eLoc, generatedMapping, range);
-        if (!oELoc) {
-
-            // console.log(EC.red('not found end'));
-            // console.log(item.url);
-            // console.log(originalMapping.sourceName);
-            // console.log('generated start', sLoc.line, sLoc.column, 'original start', oSLoc.line, oSLoc.column);
-            // console.log('generated end', eLoc.line, eLoc.column);
-
-            // can NOT use file end
-
-            return;
-        }
-
-        if (oSLoc.source !== oELoc.source) {
-            // console.log('ERROR: range crossed source file', range, oSLoc.source, oELoc.source);
-            return;
-        }
-
-        const originalEnd = originalMapping.locationToOffset(oELoc);
-        if (originalEnd < originalStart) {
-            // range start greater than end
-            addOriginalRange(originalMapping, originalEnd, originalStart, range.count);
-            return;
-        }
-
-        addOriginalRange(originalMapping, originalStart, originalEnd, range.count);
-
-    });
-
-    consumer.destroy();
-
-    // append to v8list
-    originalMappings.forEach((originalMapping, currentSource) => {
-
-        const url = fileUrls[currentSource] || currentSource;
-        const ranges = dedupeCountRanges(originalMapping.ranges);
-
-        //  console.log('add source url', url);
-
-        // original source and id
-        const source = originalMapping.source;
-        const id = Util.calculateSha1(url + source);
-
-        let ext = path.extname(currentSource);
-        let type = '';
-        if (ext) {
-            ext = ext.slice(1);
-            const reg = /^[a-z0-9]+$/;
-            if (reg.test(ext)) {
-                type = ext;
-            }
-        }
-
-
-        v8list.push({
-            url,
-            id,
-            type,
-            sourcePath: currentSource,
-            distFile: item.sourceMap.file,
-            ranges,
-            source
-        });
-
-    });
-};
-
-// =========================================================================================================
-
-const request = async (options) => {
-    if (typeof options === 'string') {
-        options = {
-            url: options
-        };
-    }
-    let err;
-    const res = await axios(options).catch((e) => {
-        err = e;
-    });
-    return [err, res];
-};
-
-const getSourceMapUrl = (content, url) => {
-
-    const m = content.match(convertSourceMap.mapFileCommentRegex);
-    if (!m) {
-        return;
-    }
-
-    const comment = m.pop();
-    const r = convertSourceMap.mapFileCommentRegex.exec(comment);
-    // for some odd reason //# .. captures in 1 and /* .. */ in 2
-    const filename = r[1] || r[2];
-
-    let mapUrl;
-
-    try {
-        mapUrl = new URL(filename, url);
-    } catch (e) {
-        // console.log(e)
-    }
-    if (mapUrl) {
-        return mapUrl.toString();
-    }
-};
-
-const resolveSourceMap = (data) => {
-    if (data) {
-        const { sources, sourcesContent } = data;
-        if (!sources || !sourcesContent) {
-            return;
-        }
-        return data;
-    }
-};
-
-const collectInlineSourceMaps = async (v8list) => {
-    const concurrency = new Concurrency();
-    for (const item of v8list) {
-
-        const { type, source } = item;
-
-        // only for js
-        if (type === 'js') {
-            const converter = convertSourceMap.fromSource(source);
-            if (converter) {
-                item.sourceMap = resolveSourceMap(converter.sourcemap);
-                continue;
-            }
-            const sourceMapUrl = getSourceMapUrl(source, item.url);
-            if (sourceMapUrl) {
-                item.sourceMapUrl = sourceMapUrl;
-                concurrency.addItem(item);
-            }
-        }
-    }
-    await concurrency.start(async (item) => {
-        const [err, res] = await request({
-            url: item.sourceMapUrl
-        });
-        if (!err && res) {
-            item.sourceMap = resolveSourceMap(res.data);
-        }
-    });
-};
-
-const collectFileSourceMaps = async (v8list, options) => {
-    const concurrency = new Concurrency();
-    for (const item of v8list) {
-
-        const {
-            type, url, source, id
-        } = item;
-
-        // remove source just keep functions to reduce artifacts size
-        delete item.source;
-
-        const sourcePath = Util.resolveArtifactSourcePath(options.artifactsDir, id);
-        if (fs.existsSync(sourcePath)) {
-            continue;
-        }
-
-        const sourceData = {
-            url,
-            id,
-            source: convertSourceMap.removeComments(source)
-        };
-
-        // only for js
-        if (type === 'js') {
-            const converter = convertSourceMap.fromSource(source);
-            if (converter) {
-                sourceData.sourceMap = resolveSourceMap(converter.sourcemap);
-                await saveSourceFile(sourcePath, sourceData);
-                continue;
-            }
-            const sourceMapUrl = getSourceMapUrl(source, item.url);
-            if (sourceMapUrl) {
-                concurrency.addItem({
-                    sourceMapUrl,
-                    sourcePath,
-                    sourceData
-                });
-                continue;
-            }
-        }
-
-        await saveSourceFile(sourcePath, sourceData);
-
-    }
-
-    await concurrency.start(async (item) => {
-        const [err, res] = await request({
-            url: item.sourceMapUrl
-        });
-        const sourceData = item.sourceData;
-        if (!err && res) {
-            sourceData.sourceMap = resolveSourceMap(res.data);
-        }
-        await saveSourceFile(item.sourcePath, sourceData);
-    });
-};
-
-const saveSourceFile = async (filePath, data) => {
-    await Util.writeFile(filePath, JSON.stringify(data));
-};
-
-const collectSourceMaps = async (v8list, options, inlineSourceMap) => {
-
-    if (inlineSourceMap) {
-        await collectInlineSourceMaps(v8list);
-        return;
-    }
-
-    await collectFileSourceMaps(v8list, options);
-
-};
-
-// =========================================================================================================
-const filterSourceMapList = (v8list, options) => {
-    const sourceMapList = [];
-    const indexes = [];
-
-    v8list.forEach((item, i) => {
-        const sourceMap = item.sourceMap;
-        if (!sourceMap) {
-            return;
-        }
-        sourceMapList.push(item);
-        indexes.push(i);
-    });
-
-    if (!sourceMapList.length) {
-        return;
-    }
-
-    // do not remove in debug mode
-    if (!options.debug) {
-        // remove dist file if found sourceMap
-        indexes.reverse();
-        indexes.forEach((i) => {
-            v8list.splice(i, 1);
-        });
-    }
-
-    return sourceMapList;
-};
-
-// requires ranges before unpack
-const unpackSourceMaps = async (v8list, options) => {
-
-    const sourceMapList = filterSourceMapList(v8list, options);
-    if (!sourceMapList) {
-        // nothing to unpack
-        return;
-    }
-
-    // console.log(sourceMapList);
-
-    // only js
-    for (const item of sourceMapList) {
-        await unpackJsSourceMap(item, v8list, options);
-    }
-};
-
-
-module.exports = {
-    collectSourceMaps,
-    unpackSourceMaps
-};