monocart-reporter 1.7.3 → 1.7.4

package/README.md

@@ -30,11 +30,18 @@
 * [Metadata](#metadata)
 * [Trend Chart](#trend-chart)
 * [Attach Lighthouse Audit Report](#attach-lighthouse-audit-report)
-* [Attach Code Coverage Report](#attach-code-coverage-report)
+* [Code Coverage Report](#code-coverage-report)
+    - [Coverage Options](#coverage-options)
+    - [Istanbul](#istanbul)
+    - [V8](#v8)
+    - [V8 to Istanbul](#v8-to-istanbul)
     - [Compare Istanbul, V8 and V8 to Istanbul](#compare-istanbul-v8-and-v8-to-istanbul)
     - [Global Coverage Report](#global-coverage-report) for Component Testing
 * [Attach Network Report](#attach-network-report)
 * [Global State Management](#global-state-management)
+    - [Setup Global State](#setup-global-state)
+    - [Get, Set, and Remove Global Data](#get-set-and-remove-global-data)
+    - [Send and Receive Messages between Processes](#send-and-receive-messages-between-processes)
 * [Merge Shard Reports](#merge-shard-reports)
 * [onEnd hook](#onend-hook)
     - [Send Email](#send-email)
@@ -46,7 +53,7 @@
     - [Teams Integration](#teams-integration)
     - [Dingtalk/Weixin/Feishu Integration](#dingtalkweixinfeishu-integration)
 * [Contributing](#contributing)
-* [Changelog](#changelog)
+* [Changelog](CHANGELOG.md)
 ## Preview
 [https://cenfun.github.io/monocart-reporter](https://cenfun.github.io/monocart-reporter)
 
@@ -625,23 +632,27 @@ test('attach lighthouse audit report', async () => {
 ```
 Preview [Audit HTML Report](https://cenfun.github.io/monocart-reporter/audit-78a0a1cc4420ee9da113/index.html)
 
-## Attach Code Coverage Report
-Attach a code coverage report with API `attachCoverageReport(data, testInfo, options)`. Arguments:
-- `data` There are two supported data inputs `Istanbul` (Object) or `V8` (Array)
-- `testInfo` see [TestInfo](https://playwright.dev/docs/api/class-testinfo)
-- `options` (Object)
-    - `title` (String) report title.
-    - `toIstanbul` (Boolean) Whether to convert to Istanbul report from V8 list. Defaults to `html-spa` report | (String) or using `html` report. V8 only. 
-    - `entryFilter` (Function) A filter function to execute for each element in the V8 list. V8 only.
-    - `sourceFilter` (Function) A filter function to execute for each element in the sources which unpacked from the source map. Sourcemap only.
-    - `watermarks` (Object) Istanbul watermarks, see [here](https://github.com/istanbuljs/istanbuljs/tree/master/packages/istanbul-lib-report) | (Array) V8 watermarks, Defaults to `[50, 80]`.
-    - `lcov` (Boolean) Whether to create `lcov.info`. (for Sonar coverage)
-    - `sourcePath` (Function) source path handler, return a new source path. ([issue#53](https://github.com/cenfun/monocart-reporter/issues/53)).
-    - `inline` (Boolean) Whether inline all scripts to the single HTML file. V8 only.
-
- (see example: [report-coverage.spec.js](https://github.com/cenfun/monocart-reporter/blob/main/tests/report-coverage/report-coverage.spec.js))
-
-- [Istanbul](https://github.com/istanbuljs) Requires your source code is instrumented. Usually we can use the tool [babel-plugin-istanbul](https://github.com/istanbuljs/babel-plugin-istanbul) to build instrumenting code. (see example: [webpack.config.js](https://github.com/cenfun/monocart-reporter-test/blob/main/packages/coverage/webpack.config.js)) The instrumented code will automatically generate coverage data and save it on `window.__coverage__`. The Istanbul HTML report will be generated and attached to the test report as an attachment.
+## Code Coverage Report
+There are two APIs for coverage report:
+- `attachCoverageReport(data, testInfo, options)`
+Attach a coverage report to a test. Arguments:
+    - `data` There are two supported data inputs `Istanbul` (Object) or `V8` (Array)
+    - `testInfo` see [TestInfo](https://playwright.dev/docs/api/class-testinfo)
+    - `options` (Object) see [Coverage Options](#coverage-options)
+- `addCoverageReport(data, testInfo)` Add coverage to global coverage report from a test. see [Global Coverage Report](#global-coverage-report)
+
+### Coverage Options
+- `title` (String) report title.
+- `toIstanbul` (Boolean) Whether to convert to Istanbul report from V8 list. Defaults to `html-spa` report | (String) or using `html` report. V8 only. 
+- `entryFilter` (Function) A filter function to execute for each element in the V8 list. V8 only.
+- `sourceFilter` (Function) A filter function to execute for each element in the sources which unpacked from the source map. Sourcemap only.
+- `watermarks` (Object) Istanbul watermarks, see [here](https://github.com/istanbuljs/istanbuljs/tree/master/packages/istanbul-lib-report) | (Array) V8 watermarks, Defaults to `[50, 80]`.
+- `lcov` (Boolean) Whether to create `lcov.info`. (for Sonar coverage)
+- `sourcePath` (Function) source path handler, return a new source path. ([issue#53](https://github.com/cenfun/monocart-reporter/issues/53)).
+- `inline` (Boolean) Whether inline all scripts to the single HTML file. V8 only.
+
+### [Istanbul](https://github.com/istanbuljs) 
+Requires your source code is instrumented. Usually we can use the tool [babel-plugin-istanbul](https://github.com/istanbuljs/babel-plugin-istanbul) to build instrumenting code. (see example: [webpack.config-istanbul.js](https://github.com/cenfun/monocart-reporter-test/blob/main/packages/coverage/webpack.config-istanbul.js)) The instrumented code will automatically generate coverage data and save it on `window.__coverage__`. The Istanbul HTML report will be generated and attached to the test report as an attachment.
 ```js
 import { test, expect } from '@playwright/test';
 import { attachCoverageReport } from 'monocart-reporter';
@@ -669,9 +680,8 @@ test('Take Istanbul coverage report', async ({ page }) => {
 });
 ```
 
-![](/docs/istanbul.png)
-
-- [V8](https://v8.dev/blog/javascript-code-coverage) ([Chromium-based only](https://chromedevtools.github.io/devtools-protocol/tot/Profiler/#type-ScriptCoverage)) Simply take coverage data with  [class-coverage](https://playwright.dev/docs/api/class-coverage) APIs, the V8 HTML report will be generated.
+### [V8](https://v8.dev/blog/javascript-code-coverage)
+Simply take coverage data with  [class-coverage](https://playwright.dev/docs/api/class-coverage) APIs, so it is [Chromium-based only](https://chromedevtools.github.io/devtools-protocol/tot/Profiler/#type-ScriptCoverage), the V8 HTML report will be generated.
 ```js
 import { test, expect } from '@playwright/test';
 import { attachCoverageReport } from 'monocart-reporter';
@@ -712,7 +722,8 @@ test('Take V8 and Istanbul coverage report', async ({ page }) => {
 
 ![](/docs/v8.gif)
 
-- `V8 to Istanbul` Take V8 coverage data with  [class-coverage](https://playwright.dev/docs/api/class-coverage) APIs, then the V8 coverage format will be converted to Istanbul's coverage format. The Istanbul HTML report will be generated. 
+### V8 to Istanbul
+Take V8 coverage data and convert it to Istanbul's coverage format. The Istanbul HTML report will be generated. 
 ```js
 const report = await attachCoverageReport(coverageList, test.info(), {
     toIstanbul: true
@@ -724,7 +735,7 @@ const report = await attachCoverageReport(coverageList, test.info(), {
 | :--------------| :------ | :------ | :----------------------  |
 | Input data format | Istanbul (Object) | V8 (Array) | V8 (Array) |
 | Options  | `watermarks: {}`  | `watermarks: [50, 80]` | `toIstanbul: true, watermarks: {}` |
-| Output report | [Istanbul HTML report](https://cenfun.github.io/monocart-reporter/coverage-6eaa280d68aea439a847/index.html) | [V8 HTML report](https://cenfun.github.io/monocart-reporter/coverage/index.html)  | [Istanbul HTML report](https://cenfun.github.io/monocart-reporter/coverage-bbea6fd47b9c551582fe/index.html) |
+| Output report | [Istanbul HTML report](https://cenfun.github.io/monocart-reporter/coverage-77aa6f37601a97417803/index.html) | [V8 HTML report](https://cenfun.github.io/monocart-reporter/coverage/index.html)  | [Istanbul HTML report](https://cenfun.github.io/monocart-reporter/coverage-01eebe0ebc796534d759-1/index.html) |
 | Indicators | Covered Lines, Branches, Statements and Functions, Execution Counts | Covered Bytes, Lines (after formatted) Execution Counts | Covered Lines, Branches, Statements and Functions, Execution Counts |
 | Source code without [instrumentation](https://github.com/istanbuljs/babel-plugin-istanbul) | ❌ | ✅ | ✅ |
 | CSS coverage | ❌ | ✅ | ❌ |
@@ -732,7 +743,8 @@ const report = await attachCoverageReport(coverageList, test.info(), {
 | Code formatting | N/A | ✅ | ❌ |
 
 ### Global Coverage Report
-The global coverage report will not be attached to any test case, but will merge all coverages into one global report after all the tests are finished. The API is `addCoverageReport(v8list, testInfo)`, currently supported `V8` only. Here is an example for Playwright Component Testing [playwright-ct-vue](https://github.com/cenfun/playwright-ct-vue).
+The global coverage report will not be attached to any test case, but will merge all coverages into one global report after all the tests are finished. 
+- The global coverage options see [Coverage Options](#coverage-options)
 ```js
 // playwright.config.js
 module.exports = {
@@ -749,6 +761,54 @@ module.exports = {
     ]
 };
 ```
+- It is recommended to use [automatic fixtures](https://playwright.dev/docs/test-fixtures#automatic-fixtures) to add coverage for each test:
+```js
+// fixtures.js for v8
+import { test as testBase, expect } from '@playwright/test';
+import { addCoverageReport } from 'monocart-reporter';
+
+const test = testBase.extend({
+    autoTestFixture: [async ({ page }, use) => {
+
+        const isChromium = test.info().project.name === 'Desktop Chromium';
+
+        // console.log('autoTestFixture setup...');
+        // coverage API is chromium only
+        if (isChromium) {
+            await Promise.all([
+                page.coverage.startJSCoverage({
+                    resetOnNavigation: false
+                }),
+                page.coverage.startCSSCoverage({
+                    resetOnNavigation: false
+                })
+            ]);
+        }
+
+        await use('autoTestFixture');
+
+        // console.log('autoTestFixture teardown...');
+        if (isChromium) {
+            const [jsCoverage, cssCoverage] = await Promise.all([
+                page.coverage.stopJSCoverage(),
+                page.coverage.stopCSSCoverage()
+            ]);
+            const coverageList = [... jsCoverage, ... cssCoverage];
+            // console.log(coverageList.map((item) => item.url));
+            await addCoverageReport(coverageList, test.info());
+        }
+
+    }, {
+        scope: 'test',
+        auto: true
+    }]
+});
+export { test, expect };
+```
+- The coverage examples for Playwright component testing:
+    - [playwright-ct-vue](https://github.com/cenfun/playwright-ct-vue)
+    - [playwright-ct-react](https://github.com/cenfun/playwright-ct-react)
+    - [playwright-ct-svelte](https://github.com/cenfun/playwright-ct-svelte)
 
 ## Attach Network Report
 Attach a network report with API `attachNetworkReport(har, testInfo)`. Arguments:
@@ -826,7 +886,7 @@ Preview [Network HTML Report](https://cenfun.github.io/monocart-reporter/network
 
 ## Global State Management
 When tests are executed in [isolation](https://playwright.dev/docs/browser-contexts) mode, the reporter and each test may run in a different process, they cannot share data with each other. we can start a local WebSocket server to serve the global data, and read/write the global data with `useState` API from a test.
-- setup global state
+### Setup Global State
 ```js
 module.exports = {
     reporter: [
@@ -850,7 +910,7 @@ module.exports = {
     ]
 };
 ```
-- get/set/remove global data
+### Get, Set, and Remove Global Data
 ```js
 const { test } = require('@playwright/test');
 const { useState } = require('monocart-reporter');
@@ -878,7 +938,23 @@ test('state test', async ({ browserName }) => {
     console.log(all);
 });
 ``` 
-- customize sending and receiving messages
+### Send and Receive Messages between Processes
+- send message and receive response from a test (child process)
+```js
+const { test } = require('@playwright/test');
+const { useState } = require('monocart-reporter');
+test('state test send message', async () => {
+    const state = useState({
+        // port: 8130
+    });
+    const response = await state.send({
+        testId: test.info().testId,
+        data: 'my test data'
+    });
+    console.log('receive response on client', response);
+});
+``` 
+- receive message and send response from global state (main process)
 ```js
 module.exports = {
     reporter: [
@@ -887,28 +963,23 @@ module.exports = {
             name: "My Test Report",
             outputFile: './test-results/report.html',
             state: {
-                // receive messages and send back response
-                onReceive: function(... args) {
-                    console.log('receive on server', args);
-                    return ['custom response', ... args];
+                onReceive: function(message) {
+                    const test = this.getTest(message.testId);
+                    if (test) {
+                        // current test
+                    }
+
+                    console.log('receive message on server', message);
+
+                    return {
+                        data: 'my response data'
+                    };
                 }
             }
         }]
     ]
 };
 ```
-```js
-const { test } = require('@playwright/test');
-const { useState } = require('monocart-reporter');
-test('state test', async ({ browserName }) => {
-    const state = useState({
-        // port: 8130
-    });
-    // send messages
-    const res = await state.send('string data', {});
-    console.log('receive on client', res);
-});
-``` 
 
 
 ## Merge Shard Reports
@@ -944,7 +1015,7 @@ await merge(reportDataList, {
 ```
 Preview [merged report](https://cenfun.github.io/monocart-reporter-test/merged)
 
-## onEnd hook
+## onEnd Hook
 The `onEnd` function will be executed after report generated. Arguments:
 - `reportData` all report data, properties:
     - `name` (String) report name 
@@ -981,54 +1052,41 @@ module.exports = {
 };
 ```
 ## Send Email
-Simply send email with [nodemailer](https://nodemailer.com), check example: [send-email](https://github.com/cenfun/monocart-reporter-test/tree/main/integrations/send-email)
-
-![](/docs/email.png)
-
+- Simply send email with [nodemailer](https://nodemailer.com)
+- Example: [send-email](https://github.com/cenfun/monocart-reporter-test/tree/main/integrations/send-email)
 
 ## Testrail Integration
-Send test results to your Testrail, check example: [testrail](https://github.com/cenfun/monocart-reporter-test/tree/main/integrations/testrail)
-
-![](/docs/testrail.png)
+- Send test results to your [Testrail](https://www.testrail.com/)
+- Example: [testrail](https://github.com/cenfun/monocart-reporter-test/tree/main/integrations/testrail)
 
 ## Jira + Zephyr Scale Integration
-Create test cycle and executions with [zephyr-scale-api](https://support.smartbear.com/zephyr-scale-cloud/api-docs/), check example: [zephyr-scale](https://github.com/cenfun/monocart-reporter-test/tree/main/integrations/zephyr-scale)
-
-![](/docs/zephyr.png)
+- Create test cycle and executions with [zephyr-scale-api](https://support.smartbear.com/zephyr-scale-cloud/api-docs/)
+- Example: [zephyr-scale](https://github.com/cenfun/monocart-reporter-test/tree/main/integrations/zephyr-scale)
 
 ## Jira + Xray Integration
 - Import test execution results with [Xray REST API](https://docs.getxray.app/display/XRAYCLOUD/REST+API)
 - Update Jira issue status with [Jira Transition API](https://developer.atlassian.com/cloud/jira/platform/rest/v3/api-group-issues/#api-rest-api-3-issue-issueidorkey-transitions-post)
-check example: [xray](https://github.com/cenfun/monocart-reporter-test/tree/main/integrations/xray)
-
-![](/docs/xray.png)
+- Example: [xray](https://github.com/cenfun/monocart-reporter-test/tree/main/integrations/xray)
 
 ## Slack Integration
-1. Simply send message with [@slack/webhook](https://github.com/slackapi/node-slack-sdk), example: [slack-webhook](https://github.com/cenfun/monocart-reporter-test/tree/main/integrations/slack-webhook)
-2. Recommended: Post chat message and upload image with [@slack/web-api](https://github.com/slackapi/node-slack-sdk), example: [slack-web-api](https://github.com/cenfun/monocart-reporter-test/tree/main/integrations/slack-web-api)
-
-![](/docs/slack.png)
+- Simply send message with [@slack/webhook](https://github.com/slackapi/node-slack-sdk) 
+- Example: [slack-webhook](https://github.com/cenfun/monocart-reporter-test/tree/main/integrations/slack-webhook)
+- Post chat message and upload image with [@slack/web-api](https://github.com/slackapi/node-slack-sdk) 
+- Example: [slack-web-api](https://github.com/cenfun/monocart-reporter-test/tree/main/integrations/slack-web-api)
 
 ## Discord Integration
-Using [Discord webhooks](https://discord.com/developers/docs/resources/webhook) to post messages to channels. check example: [discord-webhook](https://github.com/cenfun/monocart-reporter-test/tree/main/integrations/discord-webhook)
-
-![](/docs/discord.png)
+- Using [Discord webhooks](https://discord.com/developers/docs/resources/webhook) to post messages to channels.
+- Example: [discord-webhook](https://github.com/cenfun/monocart-reporter-test/tree/main/integrations/discord-webhook)
 
 ## Teams Integration
-Please create an [Incoming Webhooks](https://learn.microsoft.com/en-us/microsoftteams/platform/webhooks-and-connectors/how-to/add-incoming-webhook) for the channel first. check example: [teams-webhook](https://github.com/cenfun/monocart-reporter-test/tree/main/integrations/teams-webhook)
-
-![](/docs/teams.png)
+- Please create an [Incoming Webhooks](https://learn.microsoft.com/en-us/microsoftteams/platform/webhooks-and-connectors/how-to/add-incoming-webhook) for the channel first. 
+- Example: [teams-webhook](https://github.com/cenfun/monocart-reporter-test/tree/main/integrations/teams-webhook)
 
 ## Dingtalk/Weixin/Feishu Integration
 - [dingtalk-webhook](https://github.com/cenfun/monocart-reporter-test/tree/main/integrations/dingtalk-webhook)
 - [weixin-webhook](https://github.com/cenfun/monocart-reporter-test/tree/main/integrations/weixin-webhook)
 - [feishu-webhook](https://github.com/cenfun/monocart-reporter-test/tree/main/integrations/feishu-webhook)
 
-## Dependencies
- - UI Framework [Vue 3](https://github.com/vuejs/core)
- - Lightweight UI Components [vine-ui](https://github.com/cenfun/vine-ui)
- - High Performance Grid [turbogrid](https://github.com/cenfun/turbogrid)
- - String compress/decompress [lz-utils](https://github.com/cenfun/lz-utils)
 
 ## Contributing
 ```sh
@@ -1038,5 +1096,8 @@ npm run test
 npm run build
 npm run dev
 ```
-## CHANGELOG
-- [CHANGELOG.md](CHANGELOG.md)
+## Dependencies
+ - UI Framework [Vue 3](https://github.com/vuejs/core)
+ - Lightweight UI Components [vine-ui](https://github.com/cenfun/vine-ui)
+ - High Performance Grid [turbogrid](https://github.com/cenfun/turbogrid)
+ - String compress/decompress [lz-utils](https://github.com/cenfun/lz-utils)

package/lib/plugins/comments.js

@@ -1,6 +1,6 @@
 const fs = require('fs');
-const { parse } = require('../runtime/monocart-vendor.js');
 const Util = require('../utils/util.js');
+const parseSource = require('../utils/parse-source.js');
 
 const cacheMap = new Map();
 
@@ -15,24 +15,25 @@ function getEmptyLines(lines) {
     return emptyLines;
 }
 
-const getFileComments = (filePath, parserOptions = {}) => {
+const getFileComments = (sourcePath, options = {}) => {
 
     const map = new Map();
 
-    if (!fs.existsSync(filePath)) {
+    if (!fs.existsSync(sourcePath)) {
         return map;
     }
 
-    // console.log('babel parse file: ', filePath);
+    // console.log('babel parse file: ', sourcePath);
 
-    const source = fs.readFileSync(filePath).toString('utf-8');
+    const source = fs.readFileSync(sourcePath).toString('utf-8');
 
-    let ast;
-    try {
-        ast = parse(source, parserOptions);
-    } catch (e) {
-        Util.logError(e.message);
-        Util.logError(`failed to collect comments from the file: ${Util.relativePath(filePath)}`);
+    const ast = parseSource({
+        source,
+        sourcePath,
+        options
+    });
+
+    if (!ast) {
         return map;
     }
 

package/lib/plugins/coverage/converter/converter.js

@@ -1,11 +1,10 @@
 const path = require('path');
 
 const Util = require('../../../utils/util.js');
+const decodeMappings = require('../../../utils/decode-mappings.js');
 
 // position mapping for conversion between offset and line/column
 const PositionMapping = require('./position-mapping.js');
-
-const decodeMappings = require('./decode-mappings.js');
 const findOriginalRange = require('./find-original-range.js');
 
 const { dedupeCountRanges } = require('./dedupe.js');
@@ -222,8 +221,6 @@ const getDistCoverage = (item, state) => {
                 addJsCoverage(coverage, block, range, index, positionMapping);
             });
         });
-        // only for js
-        item.ranges = coverage.ranges;
         return coverage;
     }
 
@@ -238,10 +235,76 @@ const unpackDistSource = (item, state) => {
     const coverage = getDistCoverage(item, state);
     const sourcePath = item.sourcePath;
     state.coverageData[sourcePath] = getFileCoverage(sourcePath, coverage);
+    // after dedupe
+    item.ranges = coverage.ranges;
 };
 
 // ========================================================================================================
 
+const decodeSourceMappings = async (sourceMap, generatedPositionMapping) => {
+
+    const decodedList = await decodeMappings(sourceMap.mappings);
+
+    const originalIndexMap = new Map();
+    sourceMap.sources.forEach((item, i) => {
+        originalIndexMap.set(i, []);
+    });
+
+    const allDecodedMappings = [];
+    let generatedIndex = 0;
+    decodedList.forEach((segments, generatedLine) => {
+        let item = null;
+        segments.forEach((segment) => {
+            const [generatedColumn, sourceIndex, originalLine, originalColumn] = segment;
+            const generatedOffset = generatedPositionMapping.locationToOffset({
+                // 1-base
+                line: generatedLine + 1,
+                column: generatedColumn
+            });
+
+            item = {
+                generatedOffset,
+                generatedLine,
+                generatedColumn,
+                generatedIndex,
+
+                sourceIndex,
+                originalLine,
+                originalColumn
+            };
+
+            allDecodedMappings.push(item);
+            generatedIndex += 1;
+
+            if (typeof sourceIndex === 'undefined') {
+                return;
+            }
+
+            originalIndexMap.get(sourceIndex).push(item);
+
+        });
+
+        // line last one
+        if (item) {
+            const line = generatedPositionMapping.getLine(item.generatedLine + 1);
+            // last column
+            item.generatedEndOffset = item.generatedOffset + (line.length - item.generatedColumn);
+        }
+
+    });
+
+    // defaults to sort by generated offset, not need sort
+    // allDecodedMappings.sort((a, b) => {
+    //     return a.generatedOffset - b.generatedOffset;
+    // });
+
+    return {
+        allDecodedMappings,
+        originalIndexMap
+    };
+
+};
+
 const getOriginalDecodedMappings = (originalIndexMap, sourceIndex, positionMapping) => {
     // all mappings for the original file sorted
     const decodedMappings = originalIndexMap.get(sourceIndex);
@@ -323,70 +386,6 @@ const initOriginalList = (sourceMap, originalIndexMap, fileSources, options) =>
     return map;
 };
 
-const decodeSourceMappings = async (sourceMap, generatedPositionMapping) => {
-
-    const decodedList = await decodeMappings(sourceMap.mappings);
-
-    const originalIndexMap = new Map();
-    sourceMap.sources.forEach((item, i) => {
-        originalIndexMap.set(i, []);
-    });
-
-    const allDecodedMappings = [];
-    let generatedIndex = 0;
-    decodedList.forEach((segments, generatedLine) => {
-        let item = null;
-        segments.forEach((segment) => {
-            const [generatedColumn, sourceIndex, originalLine, originalColumn] = segment;
-            const generatedOffset = generatedPositionMapping.locationToOffset({
-                // 1-base
-                line: generatedLine + 1,
-                column: generatedColumn
-            });
-
-            item = {
-                generatedOffset,
-                generatedLine,
-                generatedColumn,
-                generatedIndex,
-
-                sourceIndex,
-                originalLine,
-                originalColumn
-            };
-
-            allDecodedMappings.push(item);
-            generatedIndex += 1;
-
-            if (typeof sourceIndex === 'undefined') {
-                return;
-            }
-
-            originalIndexMap.get(sourceIndex).push(item);
-
-        });
-
-        // line last one
-        if (item) {
-            const line = generatedPositionMapping.getLine(item.generatedLine + 1);
-            // last column
-            item.generatedEndOffset = item.generatedOffset + (line.length - item.generatedColumn);
-        }
-
-    });
-
-    // defaults to sort by generated offset, not need sort
-    // allDecodedMappings.sort((a, b) => {
-    //     return a.generatedOffset - b.generatedOffset;
-    // });
-
-    return {
-        allDecodedMappings,
-        originalIndexMap
-    };
-
-};
-
 const unpackSourceMap = async (item, state, options) => {
     const sourceMap = item.sourceMap;
     const generatedPositionMapping = state.positionMapping;

package/lib/plugins/coverage/converter/find-original-range.js

@@ -28,6 +28,11 @@ const findOffsetMapping = (generatedState, offset) => {
 
     const decodedMappings = generatedState.decodedMappings;
 
+    // possible no length
+    if (!decodedMappings.length) {
+        return;
+    }
+
     const mapping = findMapping(decodedMappings, offset);
 
     const generatedOffset = mapping.generatedOffset;