monocart-reporter 1.6.36 → 1.7.1

package/lib/plugins/coverage/istanbul/istanbul.js

@@ -28,11 +28,14 @@ const saveIstanbulReport = (coverageData, fileSources, options) => {
         data = {};
         Object.keys(coverageData).forEach((sourcePath) => {
             const d = coverageData[sourcePath];
-            const newSourcePath = options.sourcePath(sourcePath, fileSources);
-            if (newSourcePath) {
+            const s = fileSources[sourcePath];
+            const newSourcePath = options.sourcePath(sourcePath);
+            if (newSourcePath && newSourcePath !== sourcePath) {
                 sourcePath = newSourcePath;
+                // related updates
+                fileSources[sourcePath] = s;
+                d.path = sourcePath;
             }
-            d.path = sourcePath;
             data[sourcePath] = d;
         });
     }
@@ -40,6 +43,12 @@ const saveIstanbulReport = (coverageData, fileSources, options) => {
 
     const coverageMap = istanbulLibCoverage.createCoverageMap(data);
 
+    const { watermarks, defaultSummarizer } = options;
+    const istanbulOptions = {
+        watermarks,
+        defaultSummarizer
+    };
+
     // https://github.com/istanbuljs/istanbuljs/tree/master/packages/istanbul-lib-report
     const contextOptions = {
         watermarks: {
@@ -52,7 +61,7 @@ const saveIstanbulReport = (coverageData, fileSources, options) => {
         // values can be nested/flat/pkg. Defaults to 'pkg'
         defaultSummarizer: 'nested',
 
-        ... options,
+        ... istanbulOptions,
 
         dir: options.htmlDir,
         sourceFinder: (filePath) => {
@@ -87,7 +96,7 @@ const saveIstanbulReport = (coverageData, fileSources, options) => {
     // create a context for report generation
     const context = istanbulLibReport.createContext(contextOptions);
 
-    const htmlReport = istanbulReports.create('html', {});
+    const htmlReport = istanbulReports.create('html-spa', {});
     htmlReport.execute(context);
 
     const htmlPath = Util.relativePath(path.resolve(options.htmlDir, 'index.html'));
@@ -181,14 +190,25 @@ const convertV8ToIstanbul = async (v8list, options) => {
             return p;
         };
 
+        let failed = false;
         await v8toIstanbul.load().catch((e) => {
-            EC.logRed(`[MCR] ${item.filename} v8toIstanbul.load:`, e.message);
+            EC.logRed(`[MCR] ${item.sourcePath} v8toIstanbul.load:`, e.message);
+            failed = true;
         });
 
+        if (failed) {
+            continue;
+        }
+
         try {
             v8toIstanbul.applyCoverage(item.functions);
         } catch (e) {
-            EC.logRed(`[MCR] ${item.filename} v8toIstanbul.applyCoverage:`, e.message);
+            EC.logRed(`[MCR] ${item.sourcePath} v8toIstanbul.applyCoverage:`, e.message);
+            failed = true;
+        }
+
+        if (failed) {
+            continue;
         }
 
         const istanbulData = v8toIstanbul.toIstanbul();

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

@@ -99,7 +99,7 @@ const findOriginalEndPosition = (consumer, eLoc, generatedMapping, range) => {
 
 // =========================================================================================================
 
-const getOriginalMappings = (generatedMapping, consumer, options) => {
+const getOriginalMappings = (consumer, options) => {
 
     // source filter
     let sourceList = consumer.sources;
@@ -152,7 +152,7 @@ const unpackJsSourceMap = async (item, v8list, options) => {
 
     const generatedMapping = new PositionMapping(item.source);
     const consumer = await new SourceMapConsumer(sourceMap);
-    const originalMappings = getOriginalMappings(generatedMapping, consumer, options);
+    const originalMappings = getOriginalMappings(consumer, options);
 
     // generated ranges to original ranges
     item.ranges.forEach((range) => {
@@ -388,10 +388,6 @@ const saveSourceFile = async (filePath, data) => {
 
 const collectSourceMaps = async (v8list, options, inlineSourceMap) => {
 
-    if (!options.unpackSourceMap) {
-        return;
-    }
-
     if (inlineSourceMap) {
         await collectInlineSourceMaps(v8list);
         return;
@@ -419,7 +415,9 @@ const filterSourceMapList = (v8list, options) => {
         return;
     }
 
-    if (options.excludeDistFile) {
+    // do not remove in debug mode
+    if (!options.debug) {
+        // remove dist file if found sourceMap
         indexes.reverse();
         indexes.forEach((i) => {
             v8list.splice(i, 1);
@@ -432,11 +430,6 @@ const filterSourceMapList = (v8list, options) => {
 // requires ranges before unpack
 const unpackSourceMaps = async (v8list, options) => {
 
-    // collect source maps
-    if (!options.unpackSourceMap) {
-        return;
-    }
-
     const sourceMapList = filterSourceMapList(v8list, options);
     if (!sourceMapList) {
         // nothing to unpack

package/lib/plugins/coverage/v8/v8-summary.js

@@ -17,7 +17,7 @@ const getCssSummary = (item) => {
     const uncovered = total - covered;
 
     return {
-        name: item.filename,
+        name: item.sourcePath,
         type: item.type,
         url: item.url,
         total,
@@ -59,7 +59,7 @@ const getJsSummary = (item) => {
     const covered = total - uncovered;
 
     return {
-        name: item.filename,
+        name: item.sourcePath,
         type: item.type,
         url: item.url,
         total,

package/lib/plugins/coverage/v8/v8.js

@@ -3,8 +3,8 @@ const EC = require('eight-colors');
 const Util = require('../../../utils/util.js');
 const { getV8Summary } = require('./v8-summary.js');
 const { dedupeRanges } = require('./dedupe.js');
-const { getSourcePath, convertFunctionsToRanges } = require('../coverage-utils.js');
-const { collectSourceMaps, unpackSourceMaps } = require('./source-map.js');
+const { getSourcePath } = require('../coverage-utils.js');
+const { collectSourceMaps } = require('./source-map.js');
 const { mergeScriptCovs } = require('../../../runtime/monocart-coverage.js');
 
 
@@ -70,22 +70,6 @@ const initV8ListAndSourcemap = async (v8list, options, inlineSourceMap) => {
 
 // ========================================================================================================
 
-const unpackV8List = async (v8list, options) => {
-    v8list.forEach((item, i) => {
-        if (item.type === 'js') {
-            item.ranges = convertFunctionsToRanges(item.functions);
-            delete item.functions;
-        }
-    });
-
-    // requires ranges before unpack
-    await unpackSourceMaps(v8list, options);
-
-    // console.log(v8list.length);
-};
-
-// ========================================================================================================
-
 // force to async
 const mergeCssRanges = (itemList) => {
     return new Promise((resolve) => {
@@ -262,7 +246,6 @@ const saveV8Report = async (v8list, options) => {
 
 module.exports = {
     initV8ListAndSourcemap,
-    unpackV8List,
     mergeV8Coverage,
     saveV8Report
 };

package/lib/plugins/state/client.js

@@ -0,0 +1,153 @@
+const EC = require('eight-colors');
+const { WebSocket } = require('../../runtime/monocart-vendor.js');
+const Util = require('../../utils/util.js');
+
+const getServerUrl = (options = {}) => {
+    return `ws://${options.host}:${options.port}`;
+};
+
+class Client {
+
+    constructor(clientOptions) {
+        this.options = clientOptions;
+        this.requests = new Map();
+        this.resolves = [];
+
+        const serverUrl = getServerUrl(clientOptions);
+
+        // https://github.com/websockets/ws/blob/master/doc/ws.md
+        const ws = new WebSocket(serverUrl);
+
+        ws.on('error', (err) => {
+
+            // socket hang up: the port is exists but not websocket server
+            // connect ECONNREFUSED: websocket server unavailable
+
+            if (Util.isList(this.resolves)) {
+                this.resolves.forEach((item) => {
+                    item.reject(err);
+                });
+                this.resolves = null;
+            } else {
+                EC.logRed(`[SWS] websocket error: ${err.message}`);
+            }
+
+        });
+
+        ws.on('message', (data) => {
+            this.onMessage(data);
+        });
+
+        ws.on('open', () => {
+            this.ws = ws;
+            if (Util.isList(this.resolves)) {
+                this.resolves.forEach((item) => {
+                    item.resolve(ws);
+                });
+                this.resolves = null;
+            }
+        });
+    }
+
+    connect() {
+        return new Promise((resolve, reject) => {
+
+            if (this.ws) {
+                resolve(this.ws);
+                return;
+            }
+
+            if (this.resolves) {
+                this.resolves.push({
+                    resolve,
+                    reject
+                });
+            } else {
+                reject(new Error('[SWS] an error occurs when connecting websocket server'));
+            }
+        });
+    }
+
+    onMessage(buf) {
+        const message = JSON.parse(buf.toString());
+        if (!message) {
+            return;
+        }
+        const { id, data } = message;
+        if (!id) {
+            return;
+        }
+
+        const req = this.requests.get(id);
+        if (!req) {
+            return;
+        }
+
+        this.requests.delete(id);
+
+        clearTimeout(req.timeout_id);
+        req.resolve(data);
+
+    }
+
+    async execute(data) {
+
+        let err;
+        const ws = await this.connect().catch((e) => {
+            err = e;
+        });
+
+        return new Promise((resolve, reject) => {
+
+            if (!ws) {
+                reject(err);
+                return;
+            }
+
+            const id = Util.uid();
+            const timeout = this.options.timeout;
+            const timeout_id = setTimeout(() => {
+                this.requests.delete(id);
+                reject(new Error(`[SWS] Timed out receiving message from websocket server: ${timeout}ms`));
+            }, timeout);
+
+            this.requests.set(id, {
+                resolve,
+                timeout_id
+            });
+
+            const message = JSON.stringify({
+                id,
+                data
+            });
+            ws.send(message);
+        });
+    }
+
+    state() {
+        return {
+            get: (... args) => {
+                return this.execute(['get', ... args]);
+            },
+
+            set: (... args) => {
+                return this.execute(['set', ... args]);
+            },
+
+            remove: (... args) => {
+                return this.execute(['remove', ... args]);
+            },
+
+            send: (... args) => {
+                return this.execute(['send', ... args]);
+            }
+        };
+    }
+
+}
+
+
+module.exports = {
+    getServerUrl,
+    Client
+};

package/lib/plugins/state/state.js

@@ -0,0 +1,178 @@
+const EC = require('eight-colors');
+const { WebSocketServer } = require('../../runtime/monocart-vendor.js');
+const Util = require('../../utils/util.js');
+const { getServerUrl, Client } = require('./client.js');
+
+// https://github.com/websockets/ws/blob/master/doc/ws.md
+const defaultServerOptions = {
+    host: 'localhost',
+    port: 8130
+};
+
+const defaultClientOptions = {
+    ... defaultServerOptions,
+    timeout: 3000
+};
+
+const defaultStateOptions = {
+
+    server: defaultServerOptions,
+
+    // onReceive: function(... args) {
+    //     console.log('receive on server', args);
+    //     return ['custom response', ... args];
+    // },
+
+    // onClose: function(data, config) {
+    //     Object.assign(config.metadata, data);
+    // },
+
+    // key-value state data
+    data: {}
+};
+
+// ===============================================================================
+
+const clientMap = new Map();
+const useState = (options = {}) => {
+    const clientOptions = {
+        ... defaultClientOptions,
+        ... options
+    };
+
+    const clientKey = Object.keys(defaultClientOptions).map((k) => clientOptions[k]).join('-');
+    // console.log('client key', clientKey);
+
+    let client = clientMap.get(clientKey);
+    if (!client) {
+        client = new Client(clientOptions);
+        clientMap.set(clientKey, client);
+    }
+
+    return client.state();
+};
+
+// ===============================================================================
+
+const getActions = (stateData) => {
+    return {
+        get: (... args) => {
+            if (args.length) {
+                const values = args.map((k) => stateData[k]);
+                if (args.length === 1) {
+                    return values[0];
+                }
+                return values;
+            }
+            return stateData;
+        },
+        set: (... args) => {
+            if (args.length) {
+                const first = args[0];
+                if (args.length === 1 && typeof first === 'object') {
+                    Object.keys(first).forEach((key) => {
+                        stateData[key] = first[key];
+                    });
+                    return;
+                }
+                stateData[first] = args[1];
+            }
+        },
+        remove: (... args) => {
+            if (args.length) {
+                args.forEach((k) => {
+                    if (Util.hasOwn(stateData, k)) {
+                        delete stateData[k];
+                    }
+                });
+            }
+        }
+    };
+};
+
+const onMessage = async (ws, buf, options) => {
+    const message = JSON.parse(buf.toString());
+    if (!message) {
+        return;
+    }
+    const { id, data } = message;
+    if (!id || !Array.isArray(data)) {
+        return;
+    }
+
+    // first argument is action name always
+    const action = data.shift();
+
+    let resData;
+    if (action === 'send') {
+        // send handler
+        if (typeof options.onReceive === 'function') {
+            resData = await options.onReceive.apply(options, data);
+        }
+    } else {
+        // get/set/remove handler
+        const actions = getActions(options.data);
+        const handler = actions[action];
+        if (handler) {
+            resData = handler.apply(options, data);
+        }
+    }
+
+    const response = JSON.stringify({
+        id,
+        data: resData
+    });
+
+    // always response, like send action
+    // otherwise the request will be timeout
+    ws.send(response);
+
+};
+
+const createStateServer = (stateOptions) => {
+
+    const options = Util.mergeOption(defaultStateOptions, stateOptions);
+
+    if (!options.data || typeof options.data !== 'object') {
+        options.data = {};
+    }
+
+    const serverOptions = options.server;
+
+    const wss = new WebSocketServer(serverOptions);
+
+    wss.on('error', (e) => {
+        EC.logRed(`[SWS] websocket server error: ${e.message}`);
+    });
+    wss.on('wsClientError', (e) => {
+        EC.logRed(`[SWS] websocket client error: ${e.message}`);
+    });
+
+    wss.on('connection', (ws) => {
+
+        // data {Buffer|ArrayBuffer|Buffer[]}
+        ws.on('message', (data) => {
+            // console.log(data, isBinary);
+            onMessage(ws, data, options);
+        });
+    });
+
+    wss.on('listening', () => {
+        const serverUrl = getServerUrl(serverOptions);
+        console.log(`[SWS] state websocket server listening on ${EC.cyan(serverUrl)}`);
+    });
+
+    return {
+        close: async (config) => {
+            wss.close();
+            if (typeof options.onClose === 'function') {
+                await options.onClose.call(options, options.data, config);
+            }
+        }
+    };
+};
+
+module.exports = {
+    createStateServer,
+    useState
+};