@teamscale/javascript-instrumenter 1.0.0-beta.5 → 1.0.0-beta.7

package/dist/src/instrumenter/Instrumenter.js

@@ -37,12 +37,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IstanbulInstrumenter = exports.IS_INSTRUMENTED_TOKEN = void 0;
-exports.loadSourceMap = loadSourceMap;
 exports.loadInputSourceMap = loadInputSourceMap;
 exports.sourceMapFromCodeComment = sourceMapFromCodeComment;
 const Task_1 = require("./Task");
 const commons_1 = require("@cqse/commons");
-const source_map_1 = require("source-map");
 const istanbul = __importStar(require("@teamscale/lib-instrument"));
 const fs = __importStar(require("fs"));
 const mkdirp = __importStar(require("mkdirp"));
@@ -53,12 +51,12 @@ const WebToolkit_1 = require("./WebToolkit");
 const FileSystem_1 = require("./FileSystem");
 exports.IS_INSTRUMENTED_TOKEN = '$IS_JS_PROFILER_INSTRUMENTED=true';
 function readBundle(bundleContent, taskElement) {
-    const baseNameMatch = path.basename(taskElement.fromFile).match('^([a-zA-Z0-9]*).cache.js');
+    const baseNameMatch = /^([a-zA-Z0-9]*).cache.js/.exec(path.basename(taskElement.fromFile));
     const directories = path.dirname(taskElement.fromFile).split(path.sep);
     if (baseNameMatch && directories.length > 1) {
         const fragmentId = (0, WebToolkit_1.determineGwtFileUid)(taskElement.fromFile);
-        const functionCall = bundleContent.match('^([^(]+)\\((.*)\\);*\\s*$');
-        if (fragmentId && functionCall && functionCall.length === 3) {
+        const functionCall = /^([^(]+)\((.*)\);*\s*$/.exec(bundleContent);
+        if (fragmentId && functionCall?.length === 3) {
             const callInfos = (0, WebToolkit_1.extractGwtCallInfos)(bundleContent);
             if (callInfos) {
                 return {
@@ -74,23 +72,17 @@ function readBundle(bundleContent, taskElement) {
     }
     return { type: 'javascript', content: bundleContent, codeArguments: [bundleContent] };
 }
-/**
- * An instrumenter based on the IstanbulJs instrumentation and coverage framework.
- */
 class IstanbulInstrumenter {
+    vaccineSource;
+    logger;
     constructor(vaccineFilePath, logger, collector, targetBucket) {
         commons_1.Contract.require(fs.existsSync(vaccineFilePath), `The vaccine file to inject "${vaccineFilePath}" must exist!\nCWD:${process.cwd()}`);
         this.vaccineSource = this.loadVaccine(commons_1.Contract.requireNonEmpty(vaccineFilePath), collector, targetBucket);
         this.logger = logger;
     }
-    /**
-     * {@inheritDoc #IInstrumenter.instrument}
-     */
     async instrument(task) {
         this.clearFile(task.dumpOriginsFile);
         this.clearFile(task.dumpMatchedOriginsFile);
-        // We limit the number of instrumentations in parallel to one to
-        // not overuse memory (NodeJS has only limited mem to use).
         const result = await async_1.default
             .mapLimit(task.elements, 1, async (taskElement) => {
             return await this.instrumentOne(taskElement, task.excludeFilesPattern, task.originSourcePattern, task.dumpOriginsFile);
@@ -100,53 +92,35 @@ class IstanbulInstrumenter {
                 return prev.withIncrement(curr);
             }, Task_1.TaskResult.neutral(task));
         });
-        // Write the matching statistics to a JSON
         this.dumpToJson(task.dumpMatchedOriginsFile, task.originSourcePattern.retrieveMatchingFiles());
         return result;
     }
-    /**
-     * Perform the instrumentation for one given task element (file to instrument).
-     *
-     * @param collector - The collector to send the coverage information to.
-     * @param taskElement - The task element to perform the instrumentation for.
-     * @param excludeBundles - A exclude pattern to restrict which bundles should be instrumented
-     * @param sourcePattern - A pattern to restrict the instrumentation to only a fraction of the task element.
-     * @param dumpOriginsFile - A file path where all origins from the source map should be dumped in json format, or undefined if no origins should be dumped
-     */
     async instrumentOne(taskElement, excludeBundles, sourcePattern, dumpOriginsFile) {
-        // Not all file types are supported by the instrumenter
         if (!this.isFileTypeSupported(taskElement.fromFile)) {
             if (!taskElement.isInPlace()) {
                 copyToFile(taskElement.toFile, taskElement.fromFile);
             }
             return new Task_1.TaskResult(0, 0, 0, 0, 1, 0, 0);
         }
-        // Read the (supported) file
         const bundleContent = fs.readFileSync(taskElement.fromFile, 'utf8');
         const inputBundle = readBundle(bundleContent, taskElement);
-        // We skip files that we have already instrumented
         if (inputBundle.content.substring(0, Math.min(inputBundle.content.length, 100)).includes(exports.IS_INSTRUMENTED_TOKEN)) {
             if (!taskElement.isInPlace()) {
                 writeToFile(taskElement.toFile, inputBundle.content);
             }
             return new Task_1.TaskResult(0, 0, 0, 1, 0, 0, 0);
         }
-        // We might want to skip the instrumentation of the file
         if (excludeBundles.isExcluded(taskElement.fromFile)) {
             if (!taskElement.isInPlace()) {
                 copyToFile(taskElement.toFile, taskElement.fromFile);
             }
             return new Task_1.TaskResult(0, 1, 0, 0, 0, 0, 0);
         }
-        // Report progress
         this.logger.info(`Instrumenting "${path.basename(taskElement.fromFile)}"`);
-        // Load the bundles source maps
         const inputSourceMaps = loadInputSourceMaps(taskElement.fromFile, inputBundle, taskElement.externalSourceMapFile);
         if (inputSourceMaps.length === 0) {
             return Task_1.TaskResult.warning(`Failed loading input source map for ${taskElement.fromFile}.`);
         }
-        // We try to perform the instrumentation with different
-        // alternative configurations of the instrumenter.
         const configurationAlternatives = this.configurationAlternativesFor(taskElement);
         for (let i = 0; i < configurationAlternatives.length; i++) {
             const configurationAlternative = configurationAlternatives[i];
@@ -154,8 +128,6 @@ class IstanbulInstrumenter {
                 return await this.instrumentBundle(taskElement, inputBundle, inputSourceMaps, configurationAlternative, dumpOriginsFile, sourcePattern);
             }
             catch (e) {
-                // If also the last configuration alternative failed,
-                // we emit a corresponding warning or signal an error.
                 if (i === configurationAlternatives.length - 1) {
                     writeToFile(taskElement.toFile, inputBundle.content);
                     return Task_1.TaskResult.error(e);
@@ -165,22 +137,16 @@ class IstanbulInstrumenter {
         return new Task_1.TaskResult(0, 0, 0, 0, 0, 1, 0);
     }
     async instrumentBundle(taskElement, inputBundle, inputSourceMaps, configurationAlternative, dumpOriginsFile, sourcePattern) {
-        var _a;
-        // Based on the source maps of the file to instrument, we can now
-        // decide if we should NOT write an instrumented version of it
-        // and use the original code instead and write it to the target path.
-        //
         for (const inputSourceMap of inputSourceMaps.filter(map => map)) {
-            const originSourceFiles = (_a = inputSourceMap === null || inputSourceMap === void 0 ? void 0 : inputSourceMap.sources) !== null && _a !== void 0 ? _a : [];
+            const originSourceFiles = inputSourceMap?.sources ?? [];
             if (dumpOriginsFile) {
                 this.dumpToJson(dumpOriginsFile, originSourceFiles);
             }
         }
-        // The main instrumentation (adding coverage statements) is performed now:
         const instrumenter = istanbul.createInstrumenter(configurationAlternative);
         const instrumentedSources = [];
         for (let i = 0; i < inputBundle.codeArguments.length; i++) {
-            const shouldInstrument = (node, originLocation) => {
+            const shouldInstrument = (_, originLocation) => {
                 if (!originLocation.filename) {
                     return false;
                 }
@@ -208,49 +174,32 @@ class IstanbulInstrumenter {
             writeToFile(toFile, instrumentedSources[0]);
         }
     }
-    /**
-     * Loads the vaccine from the vaccine file and adjusts some template parameters.
-     *
-     * @param filePath - The path to the vaccine file.
-     * @param collector - The collector to send coverage information to.
-     * @param targetBucket - The bucket within the collector to put the coverage into.
-     */
     loadVaccine(filePath, collector, targetBucket) {
-        // We first replace parameters in the file with the
-        // actual values, for example, the collector to send the coverage information to.
         return fs.readFileSync(filePath, 'utf8')
             .replace(/\$COLLECTOR_SPECIFIER/g, JSON.stringify(collector))
             .replace(/\$BUCKET_SPECIFIER/g, Buffer.from(JSON.stringify(targetBucket)).toString('base64'));
     }
-    /**
-     * @returns whether the given file is supported for instrumentation.
-     */
     isFileTypeSupported(fileName) {
         if (fileName.endsWith('.devmode.js') || fileName.endsWith('.nocache.js')) {
-            // GWT dev mode files.
             return false;
         }
         const ext = path.extname(fileName).toLowerCase();
         return ext === '.js' || ext === '.mjs';
     }
-    /**
-     * Determine the list of configurations to try conducting the
-     * given task element.
-     */
     configurationAlternativesFor(taskElement) {
         this.logger.trace(`Determining configuration alternatives for ${taskElement.fromFile}`);
         const baseConfig = {
             isInstrumentedToken: exports.IS_INSTRUMENTED_TOKEN,
-            produceSourceMap: 'external',
+            produceSourceMap: 'none',
             codeToPrepend: this.vaccineSource,
-            compact: false // Would lead to `code generator has deoptimised the styling of` errors otherwise
+            preserveComments: false,
+            compact: false
         };
         return [
             { ...baseConfig, ...{ esModules: true } },
             { ...baseConfig, ...{ esModules: false } }
         ];
     }
-    /** Deletes the file if it exists, such that it is now ready to be appended. */
     clearFile(filePath) {
         if (filePath && fs.existsSync(filePath)) {
             try {
@@ -261,7 +210,6 @@ class IstanbulInstrumenter {
             }
         }
     }
-    /** Write the contents of the given object into the given file, if provided. */
     dumpToJson(targetFilePath, toDump) {
         if (!targetFilePath) {
             return;
@@ -275,19 +223,6 @@ class IstanbulInstrumenter {
     }
 }
 exports.IstanbulInstrumenter = IstanbulInstrumenter;
-/**
- * Extract the sourcemap from the given source code.
- *
- * @param instrumentedSource - The source code.
- * @param instrumentedSourceFileName - The file name to assume for the file name.
- */
-async function loadSourceMap(instrumentedSource, instrumentedSourceFileName) {
-    const instrumentedSourceMap = loadInputSourceMap(instrumentedSource, instrumentedSourceFileName, undefined);
-    if (instrumentedSourceMap) {
-        return await new source_map_1.SourceMapConsumer(instrumentedSourceMap);
-    }
-    return undefined;
-}
 function loadInputSourceMaps(taskFile, bundleFile, externalSourceMapFile) {
     if ((0, WebToolkit_1.isGwtBundle)(bundleFile)) {
         return (0, WebToolkit_1.loadInputSourceMapsGwt)(taskFile, bundleFile);
@@ -299,13 +234,6 @@ function loadInputSourceMaps(taskFile, bundleFile, externalSourceMapFile) {
 function loadInputSourceMapsStandard(taskFile, bundleFile, externalSourceMapFile) {
     return bundleFile.codeArguments.map(code => loadInputSourceMap(code, taskFile, externalSourceMapFile));
 }
-/**
- * Given a source code file, load the corresponding sourcemap.
- *
- * @param inputSource - The source code that might contain sourcemap comments.
- * @param taskFile - The name of the file the `inputSource` is from.
- * @param externalSourceMapFile - An external source map file to consider.
- */
 function loadInputSourceMap(inputSource, taskFile, externalSourceMapFile) {
     if (externalSourceMapFile) {
         const sourceMapOrigin = externalSourceMapFile;
@@ -318,17 +246,7 @@ function loadInputSourceMap(inputSource, taskFile, externalSourceMapFile) {
         return sourceMapFromCodeComment(inputSource, taskFile);
     }
 }
-/**
- * Extract a sourcemap for a given code comment.
- *
- * @param sourcecode - The source code that is scanned for source map comments.
- * @param sourceFilePath - The file name the code was loaded from.
- */
 function sourceMapFromCodeComment(sourcecode, sourceFilePath) {
-    // Either `//# sourceMappingURL=vendor.5d7ba975.js.map`
-    // or `//# sourceMappingURL=data:application/json;base64,eyJ2ZXJ ...`
-    //
-    // "It is reasonable for tools to also accept “//@” but “//#” is preferred."
     const re = /\/\/[#@]\s(source(?:Mapping)?URL)=\s*(\S+)/g;
     let failedLoading = 0;
     let result;
@@ -349,8 +267,7 @@ function sourceMapFromCodeComment(sourcecode, sourceFilePath) {
                         .toObject();
                 }
             }
-            catch (e) {
-                // One JS file can refer to several source map files in its comments.
+            catch {
                 failedLoading++;
             }
         }

package/dist/src/instrumenter/InstrumenterConfig.d.ts

@@ -1,10 +1,5 @@
 import { ConfigurationParameters } from '@cqse/commons';
 import { LogLevelString } from 'bunyan';
-/**
- * The options the Instrumenter is configured with.
- * For more details on these options:
- * @see #buildInstrumenterConfigurationParameters
- */
 export type InstrumenterOptions = {
     version?: boolean;
     help?: boolean;
@@ -27,10 +22,7 @@ export type InstrumenterOptions = {
     collectorConfigFileContent?: string;
     collectorOption?: string[];
     collectorOptionsList?: boolean;
+    coverageTargetFromCollector?: boolean;
 };
-/**
- * Builds and returns a configuration parameters object for the JavaScript instrumenter.
- * This function defines all supported command-line arguments and their descriptions.
- */
 export declare function buildInstrumenterConfigurationParameters(): ConfigurationParameters;
 //# sourceMappingURL=InstrumenterConfig.d.ts.map

package/dist/src/instrumenter/InstrumenterConfig.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InstrumenterConfig.d.ts","sourceRoot":"","sources":["../../../src/instrumenter/InstrumenterConfig.ts"],"names":[],"mappings":"AAAA,OAAO,EAEN,uBAAuB,EAGvB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AAGxC;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG;IACjC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,0BAA0B,CAAC,EAAE,MAAM,CAAC;IACpC,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAC/B,CAAC;AAsBF;;;GAGG;AACH,wBAAgB,wCAAwC,IAAI,uBAAuB,CA0HlF"}
+{"version":3,"file":"InstrumenterConfig.d.ts","sourceRoot":"","sources":["../../../src/instrumenter/InstrumenterConfig.ts"],"names":[],"mappings":"AAAA,OAAO,EAEN,uBAAuB,EAGvB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AAQxC,MAAM,MAAM,mBAAmB,GAAG;IACjC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,0BAA0B,CAAC,EAAE,MAAM,CAAC;IACpC,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,2BAA2B,CAAC,EAAE,OAAO,CAAC;CACtC,CAAC;AA0BF,wBAAgB,wCAAwC,IAAI,uBAAuB,CA+IlF"}

package/dist/src/instrumenter/InstrumenterConfig.js

@@ -19,10 +19,6 @@ const CONFIG_GROUP_DEBUGGING = {
     order: 4,
     title: 'Troubleshooting'
 };
-/**
- * Builds and returns a configuration parameters object for the JavaScript instrumenter.
- * This function defines all supported command-line arguments and their descriptions.
- */
 function buildInstrumenterConfigurationParameters() {
     const parameters = new commons_1.ConfigurationParameters();
     function addParameter(shortParameter, longParameter, type, options) {
@@ -53,6 +49,10 @@ function buildInstrumenterConfigurationParameters() {
         help: 'The name of the application to report coverage for. Will be used to make the automatically generated application ID more readable.',
         group: CONFIG_GROUP_TARGET_PARAMS
     });
+    addParameter(undefined, '--coverage-target-from-collector', 'bool', {
+        help: 'All coverage target (upload) parameters, for example, the target partition, shall be specified by the collector.',
+        group: CONFIG_GROUP_TARGET_PARAMS
+    });
     addParameter('-f', '--config-id', 'string', {
         help: 'The ID of the profiler configuration to use; this configuration is refetched from Teamscale once a minute.',
         group: CONFIG_GROUP_TARGET_PARAMS
@@ -127,8 +127,24 @@ function buildInstrumenterConfigurationParameters() {
         }
     });
     parameters.addArgumentCheck(options => {
-        if (!options.configId && !options.collectorConfigFile && !(Array.isArray(options.collectorOption) && options.collectorOption.length > 0)) {
-            return 'Either a configuration ID (--config-id), a collector configuration file (--collector-config-file) or explicit collector options (--collector-option) must be specified.';
+        if (options.coverageTargetFromCollector) {
+            if (Array.isArray(options.collectorOption) && options.collectorOption.length > 0) {
+                const optionsSet = new Set(options.collectorOption.map((value) => value.split("=")[0]));
+                if (optionsSet.has("teamscale-partition")
+                    || optionsSet.has("teamscale-project")
+                    || optionsSet.has("teamscale-repository")
+                    || optionsSet.has("teamscale-message")) {
+                    return 'The parameter `--coverage-target-from-collector` cannot be combined ' +
+                        'with explicitly setting upload target options in the instrumenter.';
+                }
+            }
+        }
+        else {
+            if (!options.configId && !options.collectorConfigFile && !(Array.isArray(options.collectorOption) && options.collectorOption.length > 0)) {
+                return 'Either a configuration ID (--config-id), a collector configuration file (--collector-config-file) ' +
+                    'or explicit collector options (--collector-option) must be specified. You can also decide to set all ' +
+                    'coverage upload parameters on the collector side only by setting --coverage-target-from-collector.';
+            }
         }
     });
     parameters.addArgumentCheck(options => {

package/dist/src/instrumenter/RelativeCollectorPatternParser.d.ts

@@ -1,7 +1,5 @@
-import { CollectorSpecifierRelative } from "@src/vaccine/types";
-/** Parses a relative collector pattern. */
+import { CollectorSpecifierRelative } from "../vaccine/types";
 export declare class RelativeCollectorPatternParser {
-    /** Parses the given pattern. */
     static parse(pattern: string): CollectorSpecifierRelative;
     private static apply;
 }

package/dist/src/instrumenter/RelativeCollectorPatternParser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RelativeCollectorPatternParser.d.ts","sourceRoot":"","sources":["../../../src/instrumenter/RelativeCollectorPatternParser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,0BAA0B,EAAE,MAAM,oBAAoB,CAAC;AAEhE,2CAA2C;AAC3C,qBAAa,8BAA8B;IAEvC,gCAAgC;IAChC,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,0BAA0B;IAkBzD,OAAO,CAAC,MAAM,CAAC,KAAK;CAgCvB"}
+{"version":3,"file":"RelativeCollectorPatternParser.d.ts","sourceRoot":"","sources":["../../../src/instrumenter/RelativeCollectorPatternParser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,0BAA0B,EAAE,MAAM,kBAAkB,CAAC;AAG9D,qBAAa,8BAA8B;IAGvC,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,0BAA0B;IAkBzD,OAAO,CAAC,MAAM,CAAC,KAAK;CAkCvB"}

package/dist/src/instrumenter/RelativeCollectorPatternParser.js

@@ -2,9 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RelativeCollectorPatternParser = void 0;
 const commons_1 = require("@cqse/commons");
-/** Parses a relative collector pattern. */
 class RelativeCollectorPatternParser {
-    /** Parses the given pattern. */
     static parse(pattern) {
         const parts = pattern.split(",");
         const specifier = {
@@ -31,13 +29,15 @@ class RelativeCollectorPatternParser {
                 }
                 break;
             case "replace-in-host":
-                commons_1.Contract.requireStringPattern(value, /[^ ]+ [^ ]*/, `Invalid relative collector pattern: replace-in-host must contain exactly one space to separate search string and replacement: ${value}`);
-                const parts = value.split(" ");
-                specifier.hostReplace = {
-                    search: parts[0],
-                    replace: parts[1],
-                };
-                break;
+                {
+                    commons_1.Contract.requireStringPattern(value, /[^ ]+ [^ ]*/, `Invalid relative collector pattern: replace-in-host must contain exactly one space to separate search string and replacement: ${value}`);
+                    const parts = value.split(" ");
+                    specifier.hostReplace = {
+                        search: parts[0],
+                        replace: parts[1],
+                    };
+                    break;
+                }
             case "path":
                 specifier.path = value;
                 break;

package/dist/src/instrumenter/RelativeCollectorPatternParser.test.js

@@ -1,20 +1,25 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const strict_1 = __importDefault(require("node:assert/strict"));
 const RelativeCollectorPatternParser_1 = require("./RelativeCollectorPatternParser");
-describe("SubstitutionPatternParser", () => {
-    test('empty pattern', () => {
-        expect(RelativeCollectorPatternParser_1.RelativeCollectorPatternParser.parse("")).toEqual({
+(0, node_test_1.describe)("SubstitutionPatternParser", () => {
+    (0, node_test_1.test)('empty pattern', () => {
+        strict_1.default.deepStrictEqual(RelativeCollectorPatternParser_1.RelativeCollectorPatternParser.parse(""), {
             type: "relative",
         });
     });
-    test('keep port', () => {
-        expect(RelativeCollectorPatternParser_1.RelativeCollectorPatternParser.parse("")).toEqual({
+    (0, node_test_1.test)('keep port', () => {
+        strict_1.default.deepStrictEqual(RelativeCollectorPatternParser_1.RelativeCollectorPatternParser.parse(""), {
             type: "relative",
             port: "keep",
         });
     });
-    test('all features', () => {
-        expect(RelativeCollectorPatternParser_1.RelativeCollectorPatternParser.parse("scheme:wss,port:1234,replace-in-host:foo bar,path:path/path")).toEqual({
+    (0, node_test_1.test)('all features', () => {
+        strict_1.default.deepStrictEqual(RelativeCollectorPatternParser_1.RelativeCollectorPatternParser.parse("scheme:wss,port:1234,replace-in-host:foo bar,path:path/path"), {
             type: "relative",
             hostReplace: {
                 search: "foo",

package/dist/src/instrumenter/Task.d.ts

@@ -1,107 +1,37 @@
 import { CollectorSpecifier, CoverageBucketSpecifier } from '../vaccine/types';
-/**
- * An abstract source map type.
- */
 export declare abstract class SourceMapReference {
 }
 type BaseBundle = {
     content: string;
     codeArguments: string[];
 };
-/**
- * A standard JavaScript bundle. Produced, for example, with bundlers
- * like Webpack or Vite.
- */
 export type StandardBundle = BaseBundle & {
     type: 'javascript';
 };
-/**
- * A Google Web-Toolkit Js bundle file.
- */
 export type GwtBundle = BaseBundle & {
     type: 'gwt';
     functionName: string;
     fragmentId: string;
     codeAsArrayArgument: boolean;
 };
-/**
- * A bundle to be handled by the instrumenter.
- */
 export type Bundle = BaseBundle & (StandardBundle | GwtBundle);
-/**
- * One element of an instrumentation task.
- * It corresponds to instrumenting a single file.
- */
 export declare class TaskElement {
-    /** The source file */
     readonly fromFile: string;
-    /** The destination file */
     readonly toFile: string;
-    /** An external source map file relevant for the file at hand */
     readonly externalSourceMapFile?: SourceMapReference;
     constructor(fromFile: string, toFile: string, externalSourceMap?: SourceMapReference);
-    /**
-     * Is it an in-place instrumentation task?
-     */
     isInPlace(): boolean;
 }
-/**
- * Given a command-line URL and an optional relative pattern, create a specifier for how the vaccine can
- * locate the connector.
- *
- * If a relative pattern is given, it is preferred, since the command-line interface always provides a URL
- * (the default URL in case the user didn't explicitly specify one).
- */
 export declare function createCollectorSpecifier(commandLineUrl: string, relativePattern?: string): CollectorSpecifier;
-/**
- * Patterns that define which parts of a given bundle to instrument or not.
- *
- * The patterns describe a set of filenames that can be found in the origin,
- * that is, before conducting all the transpilation steps. The source maps
- * are used to determine the original file names.
- */
 export declare class OriginSourcePattern {
-    /** Glob pattern describing the set of files in the origin for that coverage should be produced. */
     private readonly include;
-    /**
-     * Glob pattern describing the set of files in the origin for that coverage should EXPLICITLY NOT be produced.
-     * An exclude is stronger than an include.
-     */
     private readonly exclude;
-    /**
-     * Files that did match the `include` pattern.
-     */
     private readonly includeMatches;
-    /**
-     * Files that did match the `exclude` pattern.
-     */
     private readonly excludeMatches;
-    /**
-     * Files that did neither match the `exclude` nor the `include` pattern.
-     */
     private readonly neitherExcludedNorIncluded;
     constructor(include: string[] | undefined, exclude: string[] | undefined);
-    /**
-     * Does the given pattern require to include the given file?
-     *
-     * For example, a JavaScript bundle is compiled from several (origin) source files.
-     * If one of the files in the bundle is needed, then the full bundle is needed, that is,
-     * this function is required to return `true`.
-     *
-     * @param originFile - The file to decide for include or exclude.
-     *
-     * @returns `false` if (1) the given file is supposed to be excluded,
-     *   or (2) `true` if the given file is supposed to be included.
-     */
     isIncluded(originFile: string): boolean;
-    /**
-     * Variant of `isIncluded` working on a list of files to check.
-     * (Primarily, used for testing.)
-     */
     isAnyIncluded(originFiles: string[]): boolean;
-    /**
-     * Retrieve the file names that have been matching the different patterns.
-     */
     retrieveMatchingFiles(): {
         includePatterns: string[];
         excludePatterns: string[];
@@ -109,114 +39,40 @@ export declare class OriginSourcePattern {
         includeMatches: string[];
         neitherExcludedNorIncluded: string[];
     };
-    /**
-     * Returns if include/exclude patterns are specified.
-     */
     patternsSpecified(): boolean;
 }
-/**
- * Pattern describing files (bundles) to not instrument.
- */
 export declare class FileExcludePattern {
-    /**
-     * Glob pattern describing a set of files to be excluded in the instrumentation process.
-     */
     private readonly exclude;
     constructor(exclude: string[] | undefined);
-    /**
-     * Return `true` if the given `filePath` is matched by any of the patterns in `exclude`.
-     */
     isExcluded(filePath: string): boolean;
 }
-/**
- * The actual instrumentation task.
- */
 export declare class InstrumentationTask {
-    /**
-     * The collector to send coverage information to.
-     */
     readonly collector: CollectorSpecifier;
-    /**
-     * The target bucket within the collector the coverage is supposed to be sent to.
-     */
     readonly targetBucket: CoverageBucketSpecifier;
-    /**
-     * The files to instrument along with a specification of the target.
-     */
     private readonly _elements;
-    /**
-     * A pattern describing which files or fragments of a bundle to instrument
-     * based on the original file names the code was transpiled from.
-     */
     readonly originSourcePattern: OriginSourcePattern;
-    /**
-     * A pattern describing the set of files to not instrument but to output
-     * without adding instrumentations.
-     */
     readonly excludeFilesPattern: FileExcludePattern;
-    /**
-     * File to write the file-origin-mapping to.
-     */
     readonly dumpOriginsFile: string | undefined;
-    /**
-     * File to write the matched files to.
-     */
     readonly dumpMatchedOriginsFile: string | undefined;
     constructor(collector: CollectorSpecifier, targetBucket: CoverageBucketSpecifier, elements: TaskElement[], excludeFilesPattern: FileExcludePattern, originSourcePattern: OriginSourcePattern, dumpOriginsFile: string | undefined, dumpMatchedOriginsFile: string | undefined);
-    /**
-     * @returns the elements of the task.
-     */
     get elements(): TaskElement[];
 }
-/**
- * A summary of executing the instrumentation task.
- */
 export declare class TaskResult {
-    /** Number of task elements that were performed (instrumented) */
     readonly translated: number;
-    /** Number of task elements that were excluded because of corresponding include/exclude patterns. */
     readonly excluded: number;
-    /** Number of instrumentations that were taken from a cache */
     readonly translatedFromCache: number;
-    /** Number of skips due to a present instrumentation */
     readonly alreadyInstrumented: number;
-    /** Number of files not support by the instrumenter */
     readonly unsupported: number;
-    /** Number of elements for that the instrumentation failed */
     readonly failed: number;
-    /** Number of warnings that were produced during the instrumentation process */
     readonly warnings: number;
-    /** The instrumentation task for that the results were produced. */
     readonly task?: InstrumentationTask;
     constructor(translated: number, excluded: number, translatedFromCache: number, alreadyInstrumented: number, unsupported: number, failed: number, warnings: number, task?: InstrumentationTask);
-    /**
-     * Returns the sum of the present task results and the given one.
-     *
-     * @param incBy - The task result to add (as delta).
-     */
     withIncrement(incBy: TaskResult): TaskResult;
-    /**
-     * @returns the neutral task element (adding it with {@code withIncrement} does not change the result).
-     */
     static neutral(task?: InstrumentationTask): TaskResult;
-    /**
-     * @returns a task result signaling one error.
-     *
-     * @param e - The error to add.
-     */
     static error(e: Error): TaskResult;
-    /**
-     * @returns a task result signaling one warning.
-     *
-     * @param msg - The warning message to add.
-     */
     static warning(msg: string): TaskResult;
 }
-/**
- * A source map in an external file.
- */
 export declare class SourceMapFileReference extends SourceMapReference {
-    /** The path the source map is stored in */
     readonly sourceMapFilePath: string;
     constructor(sourceMapFilePath: string);
 }