monocart-coverage-reports 3.0.0 → 3.1.0

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

@@ -813,6 +813,44 @@ const checkSourceFileIndexes = (startIndexes, endIndexes) => {
 
 };
 
+const findMappingStartIndex = (mappings, offset) => {
+    let low = 0;
+    let high = mappings.length;
+    while (low < high) {
+        const mid = Math.floor((low + high) / 2);
+        if (mappings[mid].generatedOffset < offset) {
+            low = mid + 1;
+        } else {
+            high = mid;
+        }
+    }
+    return low;
+};
+
+const isFilteredRange = (start, end, mappingInfo, state) => {
+    const filtered = state.filteredSourceIndexes;
+    if (state.js || !filtered?.size) {
+        return false;
+    }
+    // A mapping after the exclusive end can belong to the next rule. Only
+    // inspect the active start segment and mappings inside this range.
+    const [startMapping] = [].concat(mappingInfo.startMappings);
+    if (!filtered.has(startMapping.sourceIndex)) {
+        return false;
+    }
+
+    const mappings = state.decodedMappings;
+    const low = findMappingStartIndex(mappings, start);
+    // Excluded endpoints alone are not enough: a retained source may have
+    // mappings in the middle of a rule that combines multiple source files.
+    for (let i = low; i < mappings.length && mappings[i].generatedOffset < end; i++) {
+        if (!filtered.has(mappings[i].sourceIndex)) {
+            return false;
+        }
+    }
+    return true;
+};
+
 const getOriginalState = (start, end, state, originalMap) => {
 
     const mappingInfo = getMappingInfo(start, end, state);
@@ -829,6 +867,7 @@ const getOriginalState = (start, end, state, originalMap) => {
     if (!results) {
         return {
             error: true,
+            filtered: isFilteredRange(start, end, mappingInfo, state),
             errors: [`invalid source indexes: ${EC.yellow(`${startIndexes} ~ ${endIndexes}`)}`]
         };
     }
@@ -845,6 +884,7 @@ const getOriginalState = (start, end, state, originalMap) => {
     if (!originalState) {
         return {
             error: true,
+            filtered: state.filteredSourceIndexes?.has(sourceIndex) && isFilteredRange(start, end, mappingInfo, state),
             errors: [`not found original file: ${EC.yellow(sourceIndex)}`]
         };
     }
@@ -904,7 +944,167 @@ const getMappingInfo = (start, end, state) => {
 };
 
 
-const findOriginalRange = (start, end, state, originalMap, options = {}) => {
+// CSS uses the shared mapping lookup, but owns its endpoint repair and validation.
+const getCssOriginalEndPosition = (cache, state) => {
+    const { end, endMappings } = cache;
+    if (!Array.isArray(endMappings)) {
+        // Synthetic line ends are already exclusive, unlike real token mappings.
+        if (endMappings.end) {
+            return {
+                originalEnd: endMappings.originalOffset
+            };
+        }
+        return getOriginalEndPosition(cache, state);
+    }
+
+    const exclusiveMappings = findMapping(state.decodedMappings, end);
+    if (Array.isArray(exclusiveMappings) && !cache.crossEnd) {
+        const [mapping] = exclusiveMappings;
+        if (mapping.end && mapping.generatedOffset === end - 1) {
+            return {
+                originalEnd: mapping.originalOffset
+            };
+        }
+    }
+    return getOriginalEndPosition(cache, state);
+};
+
+const isValidCssOriginalRange = (start, end, length) => Number.isInteger(start) && Number.isInteger(end)
+    && start >= 0 && start < end && end <= length;
+
+const getCssRangeMappingError = (start, end, state, cache) => {
+    // Matching endpoints do not guarantee a contiguous rule: a Sass mixin
+    // body can map to another file or an earlier location in the same file.
+    const mappings = state.decodedMappings;
+    const low = findMappingStartIndex(mappings, start);
+    for (let i = low; i < mappings.length && mappings[i].generatedOffset < end; i++) {
+        const mapping = mappings[i];
+        if (mapping.sourceIndex !== cache.sourceIndex) {
+            return {
+                error: true,
+                errors: ['cross-source CSS range']
+            };
+        }
+        // Synthetic line ends describe whole lines, not actual mapped tokens.
+        // Do not validate against the inferred end: indentation-based sources
+        // can map a generated closing brace back to the selector's line end.
+        if (!mapping.end && mapping.originalOffset < cache.originalStart) {
+            return {
+                error: true,
+                errors: ['mapped token before original CSS range']
+            };
+        }
+    }
+};
+
+const mapCssOriginalRange = (start, end, state, originalMap, options) => {
+    const cache = getOriginalState(start, end, state, originalMap);
+    if (cache.error) {
+        return cache;
+    }
+    const { originalStart, originalName } = getOriginalStartPosition(cache, state, options);
+    cache.originalStart = originalStart;
+    const mappingError = getCssRangeMappingError(start, end, state, cache);
+    if (mappingError) {
+        return mappingError;
+    }
+    const endResult = getCssOriginalEndPosition(cache, state);
+    if (endResult.error) {
+        return endResult;
+    }
+    const { originalEnd } = endResult;
+    const { originalState } = cache;
+    if (!isValidCssOriginalRange(originalStart, originalEnd, originalState.source.length)) {
+        return {
+            error: true,
+            errors: [`invalid original range: ${EC.yellow(`${originalStart} ~ ${originalEnd}`)}`]
+        };
+    }
+    if (originalState.locator.lineParser.commentParser.isComment(originalStart, originalEnd)) {
+        return {
+            error: true,
+            errors: ['the range in a original comment']
+        };
+    }
+    return {
+        start: originalStart,
+        end: originalEnd,
+        name: originalName,
+        originalState
+    };
+};
+
+const skipCssTrivia = (originalState, offset, direction) => {
+    const { source, locator } = originalState;
+    const { commentParser } = locator.lineParser;
+    while (offset >= 0 && offset < source.length) {
+        if ((/\s/).test(source[offset])) {
+            offset += direction;
+            continue;
+        }
+        if (commentParser.isComment(offset, offset + 1)) {
+            const comment = commentParser.findComment(offset);
+            offset = direction > 0 ? comment.end : comment.start - 1;
+            continue;
+        }
+        break;
+    }
+    return offset;
+};
+
+const fixCssOriginalRange = (result, state, end) => {
+    if (result.error || result.filtered || state.source[end - 1] !== '}') {
+        return result;
+    }
+    const { originalState } = result;
+    const { source } = originalState;
+    // A synthetic endpoint can include whitespace or comments after a brace
+    // already mapped. Do not mistake the next enclosing brace for this rule's.
+    const previousToken = skipCssTrivia(originalState, result.end - 1, -1);
+    if (source[previousToken] === '}') {
+        return result;
+    }
+    // Sass can omit both closing-brace mappings and intervening line comments.
+    // Extend only when the next non-comment, non-whitespace token is a brace.
+    const nextToken = skipCssTrivia(originalState, result.end, 1);
+    if (source[nextToken] === '}') {
+        return {
+            ... result, end: nextToken + 1
+        };
+    }
+    return result;
+};
+
+const findCssOriginalRange = (start, end, state, originalMap, options) => {
+    const { sourcePath, rangeCache } = state;
+    const key = `${start}_${end}_${Boolean(options.fixOriginalRange)}`;
+    if (rangeCache.has(key)) {
+        return rangeCache.get(key);
+    }
+
+    let result = mapCssOriginalRange(start, end, state, originalMap, options);
+    if (options.fixOriginalRange) {
+        // A closing brace may map to a mixin caller in another source. Retry the
+        // body when necessary, then repair using the full generated rule end.
+        if (result.error && !result.filtered && state.source[end - 1] === '}') {
+            result = mapCssOriginalRange(start, end - 1, state, originalMap, options);
+        }
+        result = fixCssOriginalRange(result, state, end);
+    }
+    if (result.error) {
+        result = {
+            ... result, start, end, sourcePath
+        };
+    }
+
+    // Cache the final CSS range, error or deliberate exclusion.
+    rangeCache.set(key, result);
+    return result;
+};
+
+// ========================================================================================================
+
+const findJsOriginalRange = (start, end, state, originalMap, options = {}) => {
 
     const { sourcePath, rangeCache } = state;
 
@@ -913,9 +1113,10 @@ const findOriginalRange = (start, end, state, originalMap, options = {}) => {
         return rangeCache.get(key);
     }
 
-    const createMappingError = (errors) => {
+    const createMappingError = (errors, filtered) => {
         const res = {
             error: true,
+            filtered,
             start,
             end,
             sourcePath,
@@ -930,7 +1131,7 @@ const findOriginalRange = (start, end, state, originalMap, options = {}) => {
 
     const cache = getOriginalState(start, end, state, originalMap);
     if (cache.error) {
-        return createMappingError(cache.errors);
+        return createMappingError(cache.errors, cache.filtered);
     }
 
     const originalStartResult = getOriginalStartPosition(cache, state, options);
@@ -977,4 +1178,11 @@ const findOriginalRange = (start, end, state, originalMap, options = {}) => {
 
 };
 
+const findOriginalRange = (start, end, state, originalMap, options = {}) => {
+    if (state.js) {
+        return findJsOriginalRange(start, end, state, originalMap, options);
+    }
+    return findCssOriginalRange(start, end, state, originalMap, options);
+};
+
 export { findOriginalRange };

package/lib/converter/untested.js

@@ -4,7 +4,9 @@ import { Util } from '../utils/util.js';
 
 import { pathToFileURL, fileURLToPath } from 'node:url';
 
-import { normalizeSourcePath, getSourcePathReplacer } from '../utils/source-path.js';
+import {
+    normalizeSourcePath, getSourcePathReplacer, getSourceType, cssTypes
+} from '../utils/source-path.js';
 
 // ========================================================================================================
 
@@ -67,11 +69,7 @@ const resolveFileType = (fileType, filePath) => {
     if (fileType === 'js' || fileType === 'css') {
         return fileType;
     }
-    const extname = path.extname(filePath);
-    if (['.css', '.scss', '.sass', '.less'].includes(extname)) {
-        return 'css';
-    }
-    return 'js';
+    return cssTypes.has(getSourceType(filePath)) ? 'css' : 'js';
 };
 
 const saveUntestedFileSource = async (entryFile, options) => {