slnodejs 6.0.42 → 6.1.2

package/tsOutputs/common/footprints-process-v6/hits-collector.js

@@ -1,169 +1,169 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HitsCollector = void 0;
-var sl_env_vars_1 = require("../constants/sl-env-vars");
-var original_module_loader_1 = require("../coverage-elements/original-module-loader");
-/**
- * Compare the current element hits to the previous snapshot and returns the diff
- */
-var GLOBAL_ISTANBUL_CONTAINER_NAMES = ['__coverage__'];
-var HitsCollector = /** @class */ (function () {
-    function HitsCollector(logger, globalCoverageObject) {
-        this.logger = logger;
-        this._globalCoverageObject = globalCoverageObject;
-        this.latestCoverageSnapshot = {};
-    }
-    HitsCollector.prototype.getHitElements = function () {
-        var hitFilesData = [];
-        var globalCoverage = this.getGlobalCoverageObject();
-        if (sl_env_vars_1.SlEnvVars.isUseNewUniqueId()) {
-            new original_module_loader_1.OriginalModuleLoader(globalCoverage, this.logger).load();
-        }
-        for (var filename in globalCoverage) {
-            var _a = this.getFileCoverageObjects(filename), fileCoverageSnapshot = _a.fileCoverageSnapshot, currentFileCoverage = _a.currentFileCoverage, shouldResolveRelativePath = _a.shouldResolveRelativePath;
-            var hitMethods = this.getHitMethods(currentFileCoverage, fileCoverageSnapshot);
-            var hitBranches = this.getHitBranches(currentFileCoverage, fileCoverageSnapshot);
-            if (hitMethods.length || hitBranches.length) {
-                hitFilesData.push({ filename: filename, hitMethods: hitMethods, hitBranches: hitBranches, shouldResolveRelativePath: shouldResolveRelativePath });
-            }
-        }
-        this.updateCoverageSnapshot(globalCoverage);
-        return hitFilesData;
-    };
-    Object.defineProperty(HitsCollector.prototype, "latestCoverageSnapshot", {
-        get: function () {
-            return this._latestCoverageSnapshot;
-        },
-        set: function (value) {
-            this._latestCoverageSnapshot = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(HitsCollector.prototype, "globalCoverageObject", {
-        get: function () {
-            return this._globalCoverageObject;
-        },
-        set: function (value) {
-            this._globalCoverageObject = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    HitsCollector.prototype.getHitMethods = function (currentHits, snapshotHits) {
-        var hitMethodsIndices = Object.keys(currentHits.f).filter(function (id) {
-            snapshotHits.f[id] = snapshotHits.f[id] || 0;
-            return currentHits.f[id] > snapshotHits.f[id];
-        });
-        return hitMethodsIndices.map(function (id) { return currentHits.fnMap[id]; });
-    };
-    HitsCollector.prototype.dropHits = function () {
-        this.updateCoverageSnapshot(this.getGlobalCoverageObject());
-    };
-    HitsCollector.prototype.getHitLeaves = function (currentLeaveHits, snapshotLeaveHits) {
-        var hitLeavesIndices = [];
-        snapshotLeaveHits = snapshotLeaveHits || Array(currentLeaveHits.length).fill(0);
-        currentLeaveHits.forEach(function (leaveHit, leaveIdx) {
-            if (currentLeaveHits[leaveIdx] > snapshotLeaveHits[leaveIdx]) {
-                hitLeavesIndices.push(leaveIdx);
-            }
-        });
-        return hitLeavesIndices;
-    };
-    HitsCollector.prototype.getHitBranches = function (currentHits, fileHitSnapshot) {
-        var hitBranches = [];
-        for (var branchIdx in currentHits.b) {
-            var hitLeaves = this.getHitLeaves(currentHits.b[branchIdx], fileHitSnapshot.b[branchIdx]);
-            if (hitLeaves.length > 0) {
-                var branchData = currentHits.branchMap[branchIdx];
-                hitBranches.push({ branchData: branchData, hitLeaves: hitLeaves });
-            }
-        }
-        return hitBranches;
-    };
-    HitsCollector.prototype.createEmptyIstanbulModule = function (path, useDataKey) {
-        if (useDataKey === void 0) { useDataKey = false; }
-        var emptyModule = {
-            f: {},
-            fnMap: {},
-            b: {},
-            branchMap: {},
-            path: path,
-            s: {}
-        };
-        if (useDataKey) {
-            return { data: emptyModule };
-        }
-        return emptyModule;
-    };
-    HitsCollector.prototype.getFileCoverageObjects = function (filename) {
-        var fileCoverageSnapshot = this._latestCoverageSnapshot[filename] || this.createEmptyIstanbulModule(filename);
-        var currentFileCoverage = this._globalCoverageObject[filename];
-        var shouldResolveRelativePath = true;
-        // Istanbul may holds the coverage data under 'data' key see (https://sealights.atlassian.net/browse/SLDEV-4421)
-        if (!fileCoverageSnapshot.f && fileCoverageSnapshot.data) {
-            fileCoverageSnapshot = fileCoverageSnapshot.data;
-            shouldResolveRelativePath = false;
-        }
-        if (!currentFileCoverage.f && currentFileCoverage.data) {
-            currentFileCoverage = currentFileCoverage.data;
-        }
-        return { fileCoverageSnapshot: fileCoverageSnapshot, currentFileCoverage: currentFileCoverage, shouldResolveRelativePath: shouldResolveRelativePath };
-    };
-    HitsCollector.prototype.getGlobalCoverageObject = function () {
-        if (this._globalCoverageObject)
-            return this._globalCoverageObject;
-        this._globalCoverageObject = HitsCollector.resolveGlobalCoverageObject();
-        if (!this._globalCoverageObject) {
-            this.logger.warn('Coverage object not found');
-        }
-        return this._globalCoverageObject;
-    };
-    HitsCollector.resolveGlobalCoverageObject = function () {
-        var re = /^\$\$cov_[0-9]+\$\$$/;
-        var keys = Object.keys(global);
-        for (var i = 0; i < keys.length; i++) {
-            var k = keys[i];
-            if ((re.exec(k)) !== null || GLOBAL_ISTANBUL_CONTAINER_NAMES.indexOf(k) >= 0) {
-                return global[k];
-            }
-        }
-    };
-    HitsCollector.prototype.updateCoverageSnapshot = function (currentCounters) {
-        for (var istanbulModule in currentCounters) {
-            var useDataKey = currentCounters[istanbulModule].data !== undefined;
-            this._latestCoverageSnapshot[istanbulModule] = this._latestCoverageSnapshot[istanbulModule] || this.createEmptyIstanbulModule(istanbulModule, useDataKey);
-            var f = currentCounters[istanbulModule].f || currentCounters[istanbulModule].data.f;
-            var b = currentCounters[istanbulModule].b || currentCounters[istanbulModule].data.b;
-            for (var funcId in f) {
-                this.setFunctionHit(istanbulModule, funcId, f, useDataKey);
-            }
-            for (var branchId in b) {
-                this.setBranchHit(b, branchId, istanbulModule, useDataKey);
-            }
-        }
-    };
-    HitsCollector.prototype.setBranchHit = function (b, branchId, istanbulModule, useDataKey) {
-        var currentBranchesHits = b[branchId];
-        this._latestCoverageSnapshot[istanbulModule].b[branchId] = this._latestCoverageSnapshot[istanbulModule].b[branchId] || [];
-        for (var i = 0; i < currentBranchesHits.length; i++) {
-            if (useDataKey) {
-                this._latestCoverageSnapshot[istanbulModule].data.b[branchId][i] = currentBranchesHits[i];
-            }
-            else {
-                this._latestCoverageSnapshot[istanbulModule].b[branchId][i] = currentBranchesHits[i];
-            }
-        }
-    };
-    HitsCollector.prototype.setFunctionHit = function (istanbulModule, funcId, f, useDataKey) {
-        if (useDataKey) {
-            this._latestCoverageSnapshot[istanbulModule].data.f[funcId] = f[funcId];
-        }
-        else {
-            this._latestCoverageSnapshot[istanbulModule].f[funcId] = f[funcId];
-        }
-    };
-    return HitsCollector;
-}());
-exports.HitsCollector = HitsCollector;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HitsCollector = void 0;
+var sl_env_vars_1 = require("../constants/sl-env-vars");
+var original_module_loader_1 = require("../coverage-elements/original-module-loader");
+/**
+ * Compare the current element hits to the previous snapshot and returns the diff
+ */
+var GLOBAL_ISTANBUL_CONTAINER_NAMES = ['__coverage__'];
+var HitsCollector = /** @class */ (function () {
+    function HitsCollector(logger, globalCoverageObject) {
+        this.logger = logger;
+        this._globalCoverageObject = globalCoverageObject;
+        this.latestCoverageSnapshot = {};
+    }
+    HitsCollector.prototype.getHitElements = function () {
+        var hitFilesData = [];
+        var globalCoverage = this.getGlobalCoverageObject();
+        if (sl_env_vars_1.SlEnvVars.isUseNewUniqueId()) {
+            new original_module_loader_1.OriginalModuleLoader(globalCoverage, this.logger).load();
+        }
+        for (var filename in globalCoverage) {
+            var _a = this.getFileCoverageObjects(filename), fileCoverageSnapshot = _a.fileCoverageSnapshot, currentFileCoverage = _a.currentFileCoverage, shouldResolveRelativePath = _a.shouldResolveRelativePath;
+            var hitMethods = this.getHitMethods(currentFileCoverage, fileCoverageSnapshot);
+            var hitBranches = this.getHitBranches(currentFileCoverage, fileCoverageSnapshot);
+            if (hitMethods.length || hitBranches.length) {
+                hitFilesData.push({ filename: filename, hitMethods: hitMethods, hitBranches: hitBranches, shouldResolveRelativePath: shouldResolveRelativePath });
+            }
+        }
+        this.updateCoverageSnapshot(globalCoverage);
+        return hitFilesData;
+    };
+    Object.defineProperty(HitsCollector.prototype, "latestCoverageSnapshot", {
+        get: function () {
+            return this._latestCoverageSnapshot;
+        },
+        set: function (value) {
+            this._latestCoverageSnapshot = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(HitsCollector.prototype, "globalCoverageObject", {
+        get: function () {
+            return this._globalCoverageObject;
+        },
+        set: function (value) {
+            this._globalCoverageObject = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    HitsCollector.prototype.getHitMethods = function (currentHits, snapshotHits) {
+        var hitMethodsIndices = Object.keys(currentHits.f).filter(function (id) {
+            snapshotHits.f[id] = snapshotHits.f[id] || 0;
+            return currentHits.f[id] > snapshotHits.f[id];
+        });
+        return hitMethodsIndices.map(function (id) { return currentHits.fnMap[id]; });
+    };
+    HitsCollector.prototype.dropHits = function () {
+        this.updateCoverageSnapshot(this.getGlobalCoverageObject());
+    };
+    HitsCollector.prototype.getHitLeaves = function (currentLeaveHits, snapshotLeaveHits) {
+        var hitLeavesIndices = [];
+        snapshotLeaveHits = snapshotLeaveHits || Array(currentLeaveHits.length).fill(0);
+        currentLeaveHits.forEach(function (leaveHit, leaveIdx) {
+            if (currentLeaveHits[leaveIdx] > snapshotLeaveHits[leaveIdx]) {
+                hitLeavesIndices.push(leaveIdx);
+            }
+        });
+        return hitLeavesIndices;
+    };
+    HitsCollector.prototype.getHitBranches = function (currentHits, fileHitSnapshot) {
+        var hitBranches = [];
+        for (var branchIdx in currentHits.b) {
+            var hitLeaves = this.getHitLeaves(currentHits.b[branchIdx], fileHitSnapshot.b[branchIdx]);
+            if (hitLeaves.length > 0) {
+                var branchData = currentHits.branchMap[branchIdx];
+                hitBranches.push({ branchData: branchData, hitLeaves: hitLeaves });
+            }
+        }
+        return hitBranches;
+    };
+    HitsCollector.prototype.createEmptyIstanbulModule = function (path, useDataKey) {
+        if (useDataKey === void 0) { useDataKey = false; }
+        var emptyModule = {
+            f: {},
+            fnMap: {},
+            b: {},
+            branchMap: {},
+            path: path,
+            s: {}
+        };
+        if (useDataKey) {
+            return { data: emptyModule };
+        }
+        return emptyModule;
+    };
+    HitsCollector.prototype.getFileCoverageObjects = function (filename) {
+        var fileCoverageSnapshot = this._latestCoverageSnapshot[filename] || this.createEmptyIstanbulModule(filename);
+        var currentFileCoverage = this._globalCoverageObject[filename];
+        var shouldResolveRelativePath = true;
+        // Istanbul may holds the coverage data under 'data' key see (https://sealights.atlassian.net/browse/SLDEV-4421)
+        if (!fileCoverageSnapshot.f && fileCoverageSnapshot.data) {
+            fileCoverageSnapshot = fileCoverageSnapshot.data;
+            shouldResolveRelativePath = false;
+        }
+        if (!currentFileCoverage.f && currentFileCoverage.data) {
+            currentFileCoverage = currentFileCoverage.data;
+        }
+        return { fileCoverageSnapshot: fileCoverageSnapshot, currentFileCoverage: currentFileCoverage, shouldResolveRelativePath: shouldResolveRelativePath };
+    };
+    HitsCollector.prototype.getGlobalCoverageObject = function () {
+        if (this._globalCoverageObject)
+            return this._globalCoverageObject;
+        this._globalCoverageObject = HitsCollector.resolveGlobalCoverageObject();
+        if (!this._globalCoverageObject) {
+            this.logger.warn('Coverage object not found');
+        }
+        return this._globalCoverageObject;
+    };
+    HitsCollector.resolveGlobalCoverageObject = function () {
+        var re = /^\$\$cov_[0-9]+\$\$$/;
+        var keys = Object.keys(global);
+        for (var i = 0; i < keys.length; i++) {
+            var k = keys[i];
+            if ((re.exec(k)) !== null || GLOBAL_ISTANBUL_CONTAINER_NAMES.indexOf(k) >= 0) {
+                return global[k];
+            }
+        }
+    };
+    HitsCollector.prototype.updateCoverageSnapshot = function (currentCounters) {
+        for (var istanbulModule in currentCounters) {
+            var useDataKey = currentCounters[istanbulModule].data !== undefined;
+            this._latestCoverageSnapshot[istanbulModule] = this._latestCoverageSnapshot[istanbulModule] || this.createEmptyIstanbulModule(istanbulModule, useDataKey);
+            var f = currentCounters[istanbulModule].f || currentCounters[istanbulModule].data.f;
+            var b = currentCounters[istanbulModule].b || currentCounters[istanbulModule].data.b;
+            for (var funcId in f) {
+                this.setFunctionHit(istanbulModule, funcId, f, useDataKey);
+            }
+            for (var branchId in b) {
+                this.setBranchHit(b, branchId, istanbulModule, useDataKey);
+            }
+        }
+    };
+    HitsCollector.prototype.setBranchHit = function (b, branchId, istanbulModule, useDataKey) {
+        var currentBranchesHits = b[branchId];
+        this._latestCoverageSnapshot[istanbulModule].b[branchId] = this._latestCoverageSnapshot[istanbulModule].b[branchId] || [];
+        for (var i = 0; i < currentBranchesHits.length; i++) {
+            if (useDataKey) {
+                this._latestCoverageSnapshot[istanbulModule].data.b[branchId][i] = currentBranchesHits[i];
+            }
+            else {
+                this._latestCoverageSnapshot[istanbulModule].b[branchId][i] = currentBranchesHits[i];
+            }
+        }
+    };
+    HitsCollector.prototype.setFunctionHit = function (istanbulModule, funcId, f, useDataKey) {
+        if (useDataKey) {
+            this._latestCoverageSnapshot[istanbulModule].data.f[funcId] = f[funcId];
+        }
+        else {
+            this._latestCoverageSnapshot[istanbulModule].f[funcId] = f[funcId];
+        }
+    };
+    return HitsCollector;
+}());
+exports.HitsCollector = HitsCollector;
 //# sourceMappingURL=hits-collector.js.map

package/tsOutputs/common/footprints-process-v6/hits-converter.d.ts

@@ -1,28 +1,30 @@
-/**
- * Converts element hits to footprints (uniqueIds)
- */
-import { IBranchHit, IConvertedFootprints, IHitFileData, IMethodData, IPosition, IPositionFull } from './contracts';
-import { RelativePathResolver } from './relative-path-resolver';
-import { SourceMapData } from './source-map-data';
-import { Logger } from '../contracts';
-export declare class HitsConverter {
-    static readonly METHOD_ID_DEL = "@";
-    static readonly BRANCH_ID_DEL = "|";
-    private relativePathResolver;
-    private projectRoot;
-    private sourceMapData;
-    protected logger: Logger;
-    constructor(relativePathResolver: RelativePathResolver, sourceMapData: SourceMapData, projectRoot: string, logger: Logger);
-    convertHits(hitFilesData: IHitFileData[]): IConvertedFootprints;
-    private createMethodIds;
-    protected getDeclStart(hit: IMethodData): IPosition;
-    protected getDecl(hit: IMethodData): import("./contracts").IIstanbulLocation;
-    protected getStartLoc(hit: IMethodData): IPosition;
-    protected getLeaveStartLoc(hit: IBranchHit, leaveIdx: number): IPosition;
-    private createBranchIds;
-    protected getMethodUniqueId(startLoc: IPositionFull, relativePath: string, absolutePath: string): string;
-    protected getBranchUniqueId(startLoc: IPosition, relativePath: string, absolutePath: string, leaveIndex: number): string;
-    private resolveIdParts;
-    private buildMethodUniqueId;
-    protected formatLoc(loc: IPositionFull): string;
-}
+/**
+ * Converts element hits to footprints (uniqueIds)
+ */
+import { IBranchHit, IConvertedFootprints, IHitFileData, IMethodData, IPosition, IPositionFull } from './contracts';
+import { RelativePathResolver } from './relative-path-resolver';
+import { SourceMapData } from './source-map-data';
+import { Logger } from '../contracts';
+export declare class HitsConverter {
+    static readonly METHOD_ID_DEL = "@";
+    static readonly BRANCH_ID_DEL = "|";
+    private relativePathResolver;
+    private projectRoot;
+    private sourceMapData;
+    protected logger: Logger;
+    private conversionErrors;
+    constructor(relativePathResolver: RelativePathResolver, sourceMapData: SourceMapData, projectRoot: string, logger: Logger);
+    convertHits(hitFilesData: IHitFileData[]): IConvertedFootprints;
+    private createMethodIds;
+    protected getDeclStart(hit: IMethodData): IPosition;
+    protected getDecl(hit: IMethodData): import("./contracts").IIstanbulLocation;
+    protected getStartLoc(hit: IMethodData): IPosition;
+    protected getLeaveStartLoc(hit: IBranchHit, leaveIdx: number, absolutePath: string): IPosition;
+    private createBranchIds;
+    protected getMethodUniqueId(startLoc: IPositionFull, relativePath: string, absolutePath: string): string;
+    protected getBranchUniqueId(startLoc: IPosition, relativePath: string, absolutePath: string, leaveIndex: number): string;
+    private resolveIdParts;
+    private buildMethodUniqueId;
+    private sendConversionErrors;
+    protected formatLoc(loc: IPositionFull): string;
+}

package/tsOutputs/common/footprints-process-v6/hits-converter.js

@@ -1,106 +1,136 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HitsConverter = void 0;
-var sl_env_vars_1 = require("../constants/sl-env-vars");
-var original_module_loader_1 = require("../coverage-elements/original-module-loader");
-var hits_collector_1 = require("./hits-collector");
-var new_id_resolver_1 = require("../coverage-elements/new-id-resolver");
-var HitsConverter = /** @class */ (function () {
-    function HitsConverter(relativePathResolver, sourceMapData, projectRoot, logger) {
-        this.relativePathResolver = relativePathResolver;
-        this.sourceMapData = sourceMapData;
-        this.projectRoot = projectRoot;
-        this.logger = logger;
-    }
-    HitsConverter.prototype.convertHits = function (hitFilesData) {
-        var _this = this;
-        var methodUniqueIds = [];
-        var branchUniqueIds = [];
-        if (sl_env_vars_1.SlEnvVars.isUseNewUniqueId()) {
-            new original_module_loader_1.OriginalModuleLoader(hits_collector_1.HitsCollector.resolveGlobalCoverageObject(), this.logger).load();
-        }
-        hitFilesData.forEach(function (fileHit) {
-            var relativePath = fileHit.filename;
-            if (fileHit.shouldResolveRelativePath) {
-                relativePath = _this.relativePathResolver.getRelativePath(fileHit.filename);
-            }
-            methodUniqueIds = methodUniqueIds.concat(_this.createMethodIds(fileHit.hitMethods, relativePath, fileHit.filename));
-            branchUniqueIds = branchUniqueIds.concat(_this.createBranchIds(fileHit.hitBranches, relativePath, fileHit.filename));
-        });
-        return {
-            branches: branchUniqueIds,
-            methods: methodUniqueIds
-        };
-    };
-    HitsConverter.prototype.createMethodIds = function (hitFunctions, relativePath, absolutePath) {
-        var _this = this;
-        var methodIds = [];
-        hitFunctions.forEach(function (hit) {
-            methodIds.push(_this.getMethodUniqueId(_this.getStartLoc(hit), relativePath, absolutePath));
-            if (_this.getDecl(hit) && _this.getDeclStart(hit)) {
-                methodIds.push(_this.getMethodUniqueId(_this.getDeclStart(hit), relativePath, absolutePath));
-            }
-        });
-        return methodIds;
-    };
-    HitsConverter.prototype.getDeclStart = function (hit) {
-        return hit.decl.start;
-    };
-    HitsConverter.prototype.getDecl = function (hit) {
-        return hit.decl;
-    };
-    HitsConverter.prototype.getStartLoc = function (hit) {
-        return hit.loc.start;
-    };
-    HitsConverter.prototype.getLeaveStartLoc = function (hit, leaveIdx) {
-        return hit.branchData.locations[leaveIdx].start;
-    };
-    HitsConverter.prototype.createBranchIds = function (hitFunctions, relativePath, absolutePath) {
-        var _this = this;
-        var branchIds = [];
-        hitFunctions.forEach(function (hit) {
-            hit.hitLeaves.forEach(function (leaveIdx) {
-                branchIds.push(_this.getBranchUniqueId(_this.getLeaveStartLoc(hit, leaveIdx), relativePath, absolutePath, leaveIdx));
-            });
-        });
-        return branchIds;
-    };
-    HitsConverter.prototype.getMethodUniqueId = function (startLoc, relativePath, absolutePath) {
-        var idParts = this.resolveIdParts(startLoc, relativePath, absolutePath);
-        if (sl_env_vars_1.SlEnvVars.isUseNewUniqueId()) {
-            var uniqueIdKey = idParts.relativePath + '@' + this.formatLoc(idParts.start);
-            var uniqueId = (0, new_id_resolver_1.resolveNewId)(uniqueIdKey, idParts.absolutePath, idParts.relativePath, hits_collector_1.HitsCollector.resolveGlobalCoverageObject(), this.logger);
-            if (uniqueId) {
-                return uniqueId;
-            }
-        }
-        return this.buildMethodUniqueId(idParts);
-    };
-    HitsConverter.prototype.getBranchUniqueId = function (startLoc, relativePath, absolutePath, leaveIndex) {
-        var uniqueId;
-        var parts = this.resolveIdParts(startLoc, relativePath, absolutePath);
-        if (sl_env_vars_1.SlEnvVars.isUseNewUniqueId()) {
-            var uniqueIdKey = parts.relativePath + '|' + this.formatLoc(parts.start) + '|' + leaveIndex;
-            uniqueId = (0, new_id_resolver_1.resolveNewId)(uniqueIdKey, parts.absolutePath, parts.relativePath, hits_collector_1.HitsCollector.resolveGlobalCoverageObject(), this.logger);
-        }
-        if (!uniqueId) {
-            uniqueId = parts.relativePath + HitsConverter.BRANCH_ID_DEL + this.formatLoc(parts.start) + HitsConverter.BRANCH_ID_DEL + leaveIndex;
-        }
-        return uniqueId;
-    };
-    HitsConverter.prototype.resolveIdParts = function (startLoc, relativePath, absolutePath) {
-        var sourcePosition = this.sourceMapData.getSourcePosition(relativePath, absolutePath, startLoc, this.projectRoot);
-        return sourcePosition ? sourcePosition : { relativePath: relativePath, start: startLoc, absolutePath: absolutePath };
-    };
-    HitsConverter.prototype.buildMethodUniqueId = function (parts) {
-        return parts.relativePath + HitsConverter.METHOD_ID_DEL + this.formatLoc(parts.start);
-    };
-    HitsConverter.prototype.formatLoc = function (loc) {
-        return loc.line + ',' + loc.column;
-    };
-    HitsConverter.METHOD_ID_DEL = '@';
-    HitsConverter.BRANCH_ID_DEL = '|';
-    return HitsConverter;
-}());
-exports.HitsConverter = HitsConverter;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HitsConverter = void 0;
+var sl_env_vars_1 = require("../constants/sl-env-vars");
+var original_module_loader_1 = require("../coverage-elements/original-module-loader");
+var hits_collector_1 = require("./hits-collector");
+var new_id_resolver_1 = require("../coverage-elements/new-id-resolver");
+var cockpit_notifier_1 = require("../agent-events/cockpit-notifier");
+var HitsConverter = /** @class */ (function () {
+    function HitsConverter(relativePathResolver, sourceMapData, projectRoot, logger) {
+        this.conversionErrors = [];
+        this.relativePathResolver = relativePathResolver;
+        this.sourceMapData = sourceMapData;
+        this.projectRoot = projectRoot;
+        this.logger = logger;
+    }
+    HitsConverter.prototype.convertHits = function (hitFilesData) {
+        var _this = this;
+        var methodUniqueIds = [];
+        var branchUniqueIds = [];
+        if (sl_env_vars_1.SlEnvVars.isUseNewUniqueId()) {
+            new original_module_loader_1.OriginalModuleLoader(hits_collector_1.HitsCollector.resolveGlobalCoverageObject(), this.logger).load();
+        }
+        hitFilesData.forEach(function (fileHit) {
+            var relativePath = fileHit.filename;
+            if (fileHit.shouldResolveRelativePath) {
+                relativePath = _this.relativePathResolver.getRelativePath(fileHit.filename);
+            }
+            methodUniqueIds = methodUniqueIds.concat(_this.createMethodIds(fileHit.hitMethods, relativePath, fileHit.filename));
+            branchUniqueIds = branchUniqueIds.concat(_this.createBranchIds(fileHit.hitBranches, relativePath, fileHit.filename));
+        });
+        this.sendConversionErrors();
+        return {
+            branches: branchUniqueIds,
+            methods: methodUniqueIds
+        };
+    };
+    HitsConverter.prototype.createMethodIds = function (hitFunctions, relativePath, absolutePath) {
+        var _this = this;
+        var methodIds = [];
+        hitFunctions.forEach(function (hit) {
+            methodIds.push(_this.getMethodUniqueId(_this.getStartLoc(hit), relativePath, absolutePath));
+            if (_this.getDecl(hit) && _this.getDeclStart(hit)) {
+                methodIds.push(_this.getMethodUniqueId(_this.getDeclStart(hit), relativePath, absolutePath));
+            }
+        });
+        return methodIds;
+    };
+    HitsConverter.prototype.getDeclStart = function (hit) {
+        return hit.decl.start;
+    };
+    HitsConverter.prototype.getDecl = function (hit) {
+        return hit.decl;
+    };
+    HitsConverter.prototype.getStartLoc = function (hit) {
+        return hit.loc.start;
+    };
+    HitsConverter.prototype.getLeaveStartLoc = function (hit, leaveIdx, absolutePath) {
+        var _a;
+        var position = hit.branchData.locations[leaveIdx].start;
+        var parentPosition = (_a = hit.branchData.loc) === null || _a === void 0 ? void 0 : _a.start;
+        if (!parentPosition) {
+            if (!sl_env_vars_1.SlEnvVars.isUseIstanbul()) {
+                var message = "'SL_useIstanbul' was set to 'false' but could not find 'loc' object. branch in file '" + absolutePath + "' at '" + JSON.stringify(position) + "'";
+                this.logger.error(message);
+                this.conversionErrors.push(message);
+            }
+            else {
+                this.logger.debug('Using branch position from \'locations\' object due to \'SL_useIstanbul\' set to \'true\'');
+            }
+            return position;
+        }
+        var newInstrumentation = (parentPosition.line != position.line) || (parentPosition.column != position.column);
+        if (hit.branchData.type === 'if') {
+            var message = newInstrumentation ? 'Instrumented done by istanbul-lib-instrumenter greater or equal than 5.1.0 enforcing parent positions for the else leave' :
+                'Instrumented done by istanbul-lib-instrumenter lower than 5.1.0 using parent positions for the else leave';
+            this.logger.debug(message);
+            return parentPosition;
+        }
+        return position;
+    };
+    HitsConverter.prototype.createBranchIds = function (hitFunctions, relativePath, absolutePath) {
+        var _this = this;
+        var branchIds = [];
+        hitFunctions.forEach(function (hit) {
+            hit.hitLeaves.forEach(function (leaveIdx) {
+                branchIds.push(_this.getBranchUniqueId(_this.getLeaveStartLoc(hit, leaveIdx, absolutePath), relativePath, absolutePath, leaveIdx));
+            });
+        });
+        return branchIds;
+    };
+    HitsConverter.prototype.getMethodUniqueId = function (startLoc, relativePath, absolutePath) {
+        var idParts = this.resolveIdParts(startLoc, relativePath, absolutePath);
+        if (sl_env_vars_1.SlEnvVars.isUseNewUniqueId()) {
+            var uniqueIdKey = idParts.relativePath + '@' + this.formatLoc(idParts.start);
+            var uniqueId = new_id_resolver_1.resolveNewId(uniqueIdKey, idParts.absolutePath, idParts.relativePath, hits_collector_1.HitsCollector.resolveGlobalCoverageObject(), this.logger);
+            if (uniqueId) {
+                return uniqueId;
+            }
+        }
+        return this.buildMethodUniqueId(idParts);
+    };
+    HitsConverter.prototype.getBranchUniqueId = function (startLoc, relativePath, absolutePath, leaveIndex) {
+        var uniqueId;
+        var parts = this.resolveIdParts(startLoc, relativePath, absolutePath);
+        if (sl_env_vars_1.SlEnvVars.isUseNewUniqueId()) {
+            var uniqueIdKey = parts.relativePath + '|' + this.formatLoc(parts.start) + '|' + leaveIndex;
+            uniqueId = new_id_resolver_1.resolveNewId(uniqueIdKey, parts.absolutePath, parts.relativePath, hits_collector_1.HitsCollector.resolveGlobalCoverageObject(), this.logger);
+        }
+        if (!uniqueId) {
+            uniqueId = parts.relativePath + HitsConverter.BRANCH_ID_DEL + this.formatLoc(parts.start) + HitsConverter.BRANCH_ID_DEL + leaveIndex;
+        }
+        return uniqueId;
+    };
+    HitsConverter.prototype.resolveIdParts = function (startLoc, relativePath, absolutePath) {
+        var sourcePosition = this.sourceMapData.getSourcePosition(relativePath, absolutePath, startLoc, this.projectRoot);
+        return sourcePosition ? sourcePosition : { relativePath: relativePath, start: startLoc, absolutePath: absolutePath };
+    };
+    HitsConverter.prototype.buildMethodUniqueId = function (parts) {
+        return parts.relativePath + HitsConverter.METHOD_ID_DEL + this.formatLoc(parts.start);
+    };
+    HitsConverter.prototype.sendConversionErrors = function () {
+        if (this.conversionErrors.length > 0) {
+            cockpit_notifier_1.CockpitNotifier.sendErrorsBatch(this.conversionErrors);
+            this.conversionErrors = [];
+        }
+    };
+    HitsConverter.prototype.formatLoc = function (loc) {
+        return loc.line + ',' + loc.column;
+    };
+    HitsConverter.METHOD_ID_DEL = '@';
+    HitsConverter.BRANCH_ID_DEL = '|';
+    return HitsConverter;
+}());
+exports.HitsConverter = HitsConverter;
 //# sourceMappingURL=hits-converter.js.map