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

package/dist/src/instrumenter/Instrumenter.js

@@ -1,292 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IstanbulInstrumenter = exports.IS_INSTRUMENTED_TOKEN = void 0;
-exports.loadInputSourceMap = loadInputSourceMap;
-exports.sourceMapFromCodeComment = sourceMapFromCodeComment;
-const Task_1 = require("./Task");
-const commons_1 = require("@cqse/commons");
-const istanbul = __importStar(require("@teamscale/lib-instrument"));
-const fs = __importStar(require("fs"));
-const mkdirp = __importStar(require("mkdirp"));
-const path = __importStar(require("path"));
-const convertSourceMap = __importStar(require("convert-source-map"));
-const async_1 = __importDefault(require("async"));
-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 = /^([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 = /^([^(]+)\((.*)\);*\s*$/.exec(bundleContent);
-        if (fragmentId && functionCall?.length === 3) {
-            const callInfos = (0, WebToolkit_1.extractGwtCallInfos)(bundleContent);
-            if (callInfos) {
-                return {
-                    type: 'gwt',
-                    content: bundleContent,
-                    fragmentId,
-                    functionName: callInfos.functionName,
-                    codeAsArrayArgument: callInfos.codeAsArrayArgument,
-                    codeArguments: callInfos.codeArguments
-                };
-            }
-        }
-    }
-    return { type: 'javascript', content: bundleContent, codeArguments: [bundleContent] };
-}
-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;
-    }
-    async instrument(task) {
-        this.clearFile(task.dumpOriginsFile);
-        this.clearFile(task.dumpMatchedOriginsFile);
-        const result = await async_1.default
-            .mapLimit(task.elements, 1, async (taskElement) => {
-            return await this.instrumentOne(taskElement, task.excludeFilesPattern, task.originSourcePattern, task.dumpOriginsFile);
-        })
-            .then(results => {
-            return results.reduce((prev, curr) => {
-                return prev.withIncrement(curr);
-            }, Task_1.TaskResult.neutral(task));
-        });
-        this.dumpToJson(task.dumpMatchedOriginsFile, task.originSourcePattern.retrieveMatchingFiles());
-        return result;
-    }
-    async instrumentOne(taskElement, excludeBundles, sourcePattern, dumpOriginsFile) {
-        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);
-        }
-        const bundleContent = fs.readFileSync(taskElement.fromFile, 'utf8');
-        const inputBundle = readBundle(bundleContent, taskElement);
-        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);
-        }
-        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);
-        }
-        this.logger.info(`Instrumenting "${path.basename(taskElement.fromFile)}"`);
-        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}.`);
-        }
-        const configurationAlternatives = this.configurationAlternativesFor(taskElement);
-        for (let i = 0; i < configurationAlternatives.length; i++) {
-            const configurationAlternative = configurationAlternatives[i];
-            try {
-                return await this.instrumentBundle(taskElement, inputBundle, inputSourceMaps, configurationAlternative, dumpOriginsFile, sourcePattern);
-            }
-            catch (e) {
-                if (i === configurationAlternatives.length - 1) {
-                    writeToFile(taskElement.toFile, inputBundle.content);
-                    return Task_1.TaskResult.error(e);
-                }
-            }
-        }
-        return new Task_1.TaskResult(0, 0, 0, 0, 0, 1, 0);
-    }
-    async instrumentBundle(taskElement, inputBundle, inputSourceMaps, configurationAlternative, dumpOriginsFile, sourcePattern) {
-        for (const inputSourceMap of inputSourceMaps.filter(map => map)) {
-            const originSourceFiles = inputSourceMap?.sources ?? [];
-            if (dumpOriginsFile) {
-                this.dumpToJson(dumpOriginsFile, originSourceFiles);
-            }
-        }
-        const instrumenter = istanbul.createInstrumenter(configurationAlternative);
-        const instrumentedSources = [];
-        for (let i = 0; i < inputBundle.codeArguments.length; i++) {
-            const shouldInstrument = (_, originLocation) => {
-                if (!originLocation.filename) {
-                    return false;
-                }
-                return sourcePattern.isIncluded(originLocation.filename);
-            };
-            const instrumented = await instrumenter.instrument(inputBundle.codeArguments[i], taskElement.fromFile, inputSourceMaps[i], shouldInstrument);
-            instrumentedSources.push(instrumented);
-        }
-        this.writeBundleFile(taskElement.toFile, inputBundle, instrumentedSources);
-        return new Task_1.TaskResult(1, 0, 0, 0, 0, 0, 0);
-    }
-    writeBundleFile(toFile, inputBundle, instrumentedSources) {
-        if (inputBundle.type === 'gwt') {
-            commons_1.Contract.require(instrumentedSources.length === 1, 'Assuming only one code fragment to be passed as argument.');
-            const processedCodeString = JSON.stringify(`${this.vaccineSource} ${instrumentedSources[0]}`);
-            if (inputBundle.codeAsArrayArgument) {
-                writeToFile(toFile, `${exports.IS_INSTRUMENTED_TOKEN} ${inputBundle.functionName}([${processedCodeString}]);`);
-            }
-            else {
-                writeToFile(toFile, `${exports.IS_INSTRUMENTED_TOKEN} ${inputBundle.functionName}(${processedCodeString});`);
-            }
-        }
-        else {
-            commons_1.Contract.require(instrumentedSources.length === 1, 'Assuming only one code fragment to be passed as argument for JavaScript bundles.');
-            writeToFile(toFile, instrumentedSources[0]);
-        }
-    }
-    loadVaccine(filePath, collector, targetBucket) {
-        return fs.readFileSync(filePath, 'utf8')
-            .replace(/\$COLLECTOR_SPECIFIER/g, JSON.stringify(collector))
-            .replace(/\$BUCKET_SPECIFIER/g, Buffer.from(JSON.stringify(targetBucket)).toString('base64'));
-    }
-    isFileTypeSupported(fileName) {
-        if (fileName.endsWith('.devmode.js') || fileName.endsWith('.nocache.js')) {
-            return false;
-        }
-        const ext = path.extname(fileName).toLowerCase();
-        return ext === '.js' || ext === '.mjs';
-    }
-    configurationAlternativesFor(taskElement) {
-        this.logger.trace(`Determining configuration alternatives for ${taskElement.fromFile}`);
-        const baseConfig = {
-            isInstrumentedToken: exports.IS_INSTRUMENTED_TOKEN,
-            produceSourceMap: 'none',
-            codeToPrepend: this.vaccineSource,
-            preserveComments: false,
-            compact: false
-        };
-        return [
-            { ...baseConfig, ...{ esModules: true } },
-            { ...baseConfig, ...{ esModules: false } }
-        ];
-    }
-    clearFile(filePath) {
-        if (filePath && fs.existsSync(filePath)) {
-            try {
-                fs.unlinkSync(filePath);
-            }
-            catch (err) {
-                this.logger.warn(`Could not clear file ${filePath}:` + err);
-            }
-        }
-    }
-    dumpToJson(targetFilePath, toDump) {
-        if (!targetFilePath) {
-            return;
-        }
-        const jsonContent = JSON.stringify(toDump, null, 2);
-        fs.writeFile(targetFilePath, jsonContent + '\n', { flag: 'a' }, error => {
-            if (error) {
-                this.logger.warn(`Could not dump JSON to file ${targetFilePath}:` + error.message);
-            }
-        });
-    }
-}
-exports.IstanbulInstrumenter = IstanbulInstrumenter;
-function loadInputSourceMaps(taskFile, bundleFile, externalSourceMapFile) {
-    if ((0, WebToolkit_1.isGwtBundle)(bundleFile)) {
-        return (0, WebToolkit_1.loadInputSourceMapsGwt)(taskFile, bundleFile);
-    }
-    else {
-        return loadInputSourceMapsStandard(taskFile, bundleFile, externalSourceMapFile);
-    }
-}
-function loadInputSourceMapsStandard(taskFile, bundleFile, externalSourceMapFile) {
-    return bundleFile.codeArguments.map(code => loadInputSourceMap(code, taskFile, externalSourceMapFile));
-}
-function loadInputSourceMap(inputSource, taskFile, externalSourceMapFile) {
-    if (externalSourceMapFile) {
-        const sourceMapOrigin = externalSourceMapFile;
-        if (!(sourceMapOrigin instanceof Task_1.SourceMapFileReference)) {
-            throw new commons_1.IllegalArgumentException('Type of source map not yet supported!');
-        }
-        return (0, FileSystem_1.sourceMapFromMapFile)(sourceMapOrigin.sourceMapFilePath);
-    }
-    else {
-        return sourceMapFromCodeComment(inputSource, taskFile);
-    }
-}
-function sourceMapFromCodeComment(sourcecode, sourceFilePath) {
-    const re = /\/\/[#@]\s(source(?:Mapping)?URL)=\s*(\S+)/g;
-    let failedLoading = 0;
-    let result;
-    let matched;
-    do {
-        matched = re.exec(sourcecode);
-        if (matched) {
-            const sourceMapComment = matched[0];
-            try {
-                if (sourceMapComment.slice(0, 50).indexOf('data:application/json') > 0) {
-                    result = convertSourceMap.fromComment(sourceMapComment).toObject();
-                }
-                else {
-                    result = convertSourceMap
-                        .fromMapFileComment(sourceMapComment, function (filename) {
-                        return fs.readFileSync(path.resolve(path.dirname(sourceFilePath), filename), 'utf-8');
-                    })
-                        .toObject();
-                }
-            }
-            catch {
-                failedLoading++;
-            }
-        }
-    } while (matched);
-    if (result) {
-        return result;
-    }
-    if (failedLoading > 0) {
-        throw new commons_1.IllegalArgumentException('None of the referenced source map files loaded!');
-    }
-    else {
-        return undefined;
-    }
-}
-function writeToFile(filePath, fileContent) {
-    mkdirp.sync(path.dirname(filePath));
-    fs.writeFileSync(filePath, fileContent);
-}
-function copyToFile(targetFilePath, sourceFilePath) {
-    mkdirp.sync(path.dirname(targetFilePath));
-    fs.copyFileSync(sourceFilePath, targetFilePath);
-}

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

@@ -1,28 +0,0 @@
-import { ConfigurationParameters } from '@cqse/commons';
-import { LogLevelString } from 'bunyan';
-export type InstrumenterOptions = {
-    version?: boolean;
-    help?: boolean;
-    input?: string[];
-    inPlace?: boolean;
-    to?: string;
-    logLevel?: LogLevelString;
-    configId?: string;
-    appName?: string;
-    commit?: string;
-    sourceMap?: string;
-    collector: string;
-    relativeCollector?: string;
-    includeOrigin?: string[];
-    excludeOrigin?: string[];
-    excludeBundle?: string[];
-    dumpOriginsTo?: string;
-    dumpOriginMatchesTo?: string;
-    collectorConfigFile?: string;
-    collectorConfigFileContent?: string;
-    collectorOption?: string[];
-    collectorOptionsList?: boolean;
-    coverageTargetFromCollector?: boolean;
-};
-export declare function buildInstrumenterConfigurationParameters(): ConfigurationParameters;
-//# sourceMappingURL=InstrumenterConfig.d.ts.map

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

@@ -1 +0,0 @@
-{"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

@@ -1,159 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildInstrumenterConfigurationParameters = buildInstrumenterConfigurationParameters;
-const commons_1 = require("@cqse/commons");
-const commons_2 = require("@cqse/commons");
-const CONFIG_GROUP_INPUT = {
-    order: 1,
-    title: 'Instrumenter Input and Output'
-};
-const CONFIG_GROUP_TARGET_PARAMS = {
-    order: 2,
-    title: 'Coverage Target Parameters'
-};
-const CONFIG_GROUP_COVERAGE_SUBJECT = {
-    order: 3,
-    title: 'Coverage Subject'
-};
-const CONFIG_GROUP_DEBUGGING = {
-    order: 4,
-    title: 'Troubleshooting'
-};
-function buildInstrumenterConfigurationParameters() {
-    const parameters = new commons_1.ConfigurationParameters();
-    function addParameter(shortParameter, longParameter, type, options) {
-        parameters.addParameter(shortParameter, longParameter, type, options);
-    }
-    addParameter('-i', '--input', 'string[]', {
-        help: 'The input file(s) or folder(s) to instrument.',
-        group: CONFIG_GROUP_INPUT
-    });
-    addParameter('-l', '--in-place', 'bool', {
-        help: 'If set, the original files to instrument are replaced by their instrumented counterparts.',
-        group: CONFIG_GROUP_INPUT
-    });
-    addParameter('-o', '--to', 'string', {
-        help: 'Path (directory or file name) to write the instrumented version to.',
-        group: CONFIG_GROUP_INPUT
-    });
-    addParameter('-r', '--commit', 'string', {
-        help: 'The commit (<branch name>:<UNIX timestamp in milliseconds>) or revision (Git hash) of the code to report coverage for.',
-        group: CONFIG_GROUP_TARGET_PARAMS
-    });
-    addParameter('-c', '--collector', 'string', {
-        help: 'The collector (`host:port` or `wss://host:port/` or `ws://host:port/`) to send coverage information to.',
-        default: 'ws://localhost:54678',
-        group: CONFIG_GROUP_TARGET_PARAMS
-    });
-    addParameter('-a', '--app-name', 'string', {
-        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
-    });
-    addParameter('-t', '--collector-config-file', 'string', {
-        help: 'Provide a configuration file that specifies or overwrites the configuration of the Coverage Collector.',
-        group: CONFIG_GROUP_TARGET_PARAMS
-    });
-    addParameter(undefined, '--collector-option', 'string[]', {
-        help: 'Sets a given collector configuration option. Provided as key=value pairs.',
-        group: CONFIG_GROUP_TARGET_PARAMS
-    });
-    addParameter(undefined, '--collector-options-list', 'bool', {
-        help: 'Lists the options that can be set for the collector, via a --collector-config-file or via --collector-option.',
-        group: CONFIG_GROUP_TARGET_PARAMS
-    });
-    addParameter(undefined, '--source-map', 'string', {
-        help: 'External location of source-map files to consider.',
-        group: CONFIG_GROUP_COVERAGE_SUBJECT
-    });
-    addParameter(undefined, '--relative-collector', 'string', {
-        help: 'Pattern used to determine the collector URL from the application hostname.'
-            + ' Useful for Kubernetes deployments where the collector URL is not known at instrumentation time.'
-            + ' Example: `replace-in-host:app collector,scheme:wss`.'
-            + ' This causes the first occurrence of `app` in the application hostname to be replaced with `collector`'
-            + ' and the URL scheme changed to wss.'
-            + ' Available operations:'
-            + ' `replace-in-host:SEARCH REPLACE` replaces the literal term SEARCH once in the hostname with REPLACE.'
-            + ' `port:NUMBER` changes the port to NUMBER.'
-            + ' `port:keep` keeps the port of the application (instead of using the chosen scheme\'s default port).'
-            + ' `scheme:SCHEME` changes the URL scheme to one of ws, wss, http or https.'
-            + ' `path:PATH` uses the URL path PATH (instead of no path).',
-        group: CONFIG_GROUP_TARGET_PARAMS
-    });
-    addParameter('-x', '--exclude-origin', 'string[]', {
-        help: 'Glob pattern(s) of files in the source origin to not produce coverage for. Multiple patterns can be separated by comma.',
-        group: CONFIG_GROUP_INPUT
-    });
-    addParameter('-k', '--include-origin', 'string[]', {
-        help: 'Glob pattern(s) of files in the source origin to produce coverage for. Multiple patterns can be separated by comma.',
-        group: CONFIG_GROUP_INPUT
-    });
-    addParameter('-e', '--exclude-bundle', 'string[]', {
-        help: 'Glob pattern(s) of input (bundle) files to keep unchanged (to not instrument).',
-        group: CONFIG_GROUP_INPUT
-    });
-    addParameter('-p', '--dump-origins-to', 'string', {
-        help: 'Path specifying where to dump source origins file names, based on the source maps, as a JSON file.',
-        group: CONFIG_GROUP_DEBUGGING
-    });
-    addParameter('-m', '--dump-origin-matches-to', 'string', {
-        help: 'Path specifying where to dump a JSON with the names of the files that have matched the origin include/exclude patterns.',
-        group: CONFIG_GROUP_DEBUGGING
-    });
-    addParameter(undefined, '--log-level', 'string', {
-        help: 'Log level', default: 'info', group: CONFIG_GROUP_DEBUGGING
-    });
-    parameters.addArgumentCheck(options => {
-        if (!Array.isArray(options.input) || options.input.length === 0) {
-            return 'The --input parameter must be provided with the list of files or folders to instrument.';
-        }
-    });
-    parameters.addRequiredArgumentFor('commit');
-    parameters.addArgumentCheck(options => {
-        if (!(0, commons_2.isValidCommitInfo)(options.commit)) {
-            return 'The given commit must be of the form <branch>:<UNIX timestamp in milliseconds> or a Git hash.';
-        }
-    });
-    parameters.addArgumentCheck(options => {
-        if (!options.collector && !options.relativeCollector) {
-            return 'Either a collector URL or a relative collector URL must be specified.';
-        }
-    });
-    parameters.addArgumentCheck(options => {
-        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 => {
-        if (options.logLevel !== undefined) {
-            const validLevels = ["trace", "debug", "info", "warn", "error", "fatal"];
-            if (!validLevels.includes(options.logLevel)) {
-                return "Please provide a valid value for --log-level. One of: " + validLevels.join(", ");
-            }
-        }
-    });
-    return parameters;
-}

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

@@ -1,6 +0,0 @@
-import { CollectorSpecifierRelative } from "../vaccine/types";
-export declare class RelativeCollectorPatternParser {
-    static parse(pattern: string): CollectorSpecifierRelative;
-    private static apply;
-}
-//# sourceMappingURL=RelativeCollectorPatternParser.d.ts.map

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

@@ -1 +0,0 @@
-{"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

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RelativeCollectorPatternParser = void 0;
-const commons_1 = require("@cqse/commons");
-class RelativeCollectorPatternParser {
-    static parse(pattern) {
-        const parts = pattern.split(",");
-        const specifier = {
-            type: "relative"
-        };
-        for (const part of parts) {
-            const colonIndex = part.indexOf(":");
-            commons_1.Contract.require(colonIndex > -1, `Invalid relative collector pattern ${pattern}: ${part} has no colon after the operation`);
-            const operation = part.substring(0, colonIndex);
-            const value = part.substring(colonIndex + 1);
-            RelativeCollectorPatternParser.apply(operation, value, specifier);
-        }
-        return specifier;
-    }
-    static apply(operation, value, specifier) {
-        switch (operation) {
-            case "port":
-                commons_1.Contract.requireStringPattern(value, /[0-9]+|keep/, `Invalid relative collector pattern: port must be a number: ${value}`);
-                if (value === "keep") {
-                    specifier.port = value;
-                }
-                else {
-                    specifier.port = parseInt(value);
-                }
-                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;
-                }
-            case "path":
-                specifier.path = value;
-                break;
-            case "scheme":
-                commons_1.Contract.requireStringPattern(value, /ws|wss|http|https/i, `Invalid relative collector pattern: scheme must be one of ws, wss, http or https: ${value}`);
-                specifier.scheme = value.toLowerCase();
-                break;
-            default:
-                throw new commons_1.IllegalArgumentException(`Invalid relative collector pattern: unknown operation ${operation}`);
-        }
-    }
-}
-exports.RelativeCollectorPatternParser = RelativeCollectorPatternParser;

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

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=RelativeCollectorPatternParser.test.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"RelativeCollectorPatternParser.test.d.ts","sourceRoot":"","sources":["../../../src/instrumenter/RelativeCollectorPatternParser.test.ts"],"names":[],"mappings":""}

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

@@ -1,33 +0,0 @@
-"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");
-(0, node_test_1.describe)("SubstitutionPatternParser", () => {
-    (0, node_test_1.test)('empty pattern', () => {
-        strict_1.default.deepStrictEqual(RelativeCollectorPatternParser_1.RelativeCollectorPatternParser.parse(""), {
-            type: "relative",
-        });
-    });
-    (0, node_test_1.test)('keep port', () => {
-        strict_1.default.deepStrictEqual(RelativeCollectorPatternParser_1.RelativeCollectorPatternParser.parse(""), {
-            type: "relative",
-            port: "keep",
-        });
-    });
-    (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",
-                replace: "bar",
-            },
-            path: "path/path",
-            port: 1234,
-            scheme: "wss",
-        });
-    });
-});

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

@@ -1,80 +0,0 @@
-import { CollectorSpecifier, CoverageBucketSpecifier } from '../vaccine/types';
-export declare abstract class SourceMapReference {
-}
-type BaseBundle = {
-    content: string;
-    codeArguments: string[];
-};
-export type StandardBundle = BaseBundle & {
-    type: 'javascript';
-};
-export type GwtBundle = BaseBundle & {
-    type: 'gwt';
-    functionName: string;
-    fragmentId: string;
-    codeAsArrayArgument: boolean;
-};
-export type Bundle = BaseBundle & (StandardBundle | GwtBundle);
-export declare class TaskElement {
-    readonly fromFile: string;
-    readonly toFile: string;
-    readonly externalSourceMapFile?: SourceMapReference;
-    constructor(fromFile: string, toFile: string, externalSourceMap?: SourceMapReference);
-    isInPlace(): boolean;
-}
-export declare function createCollectorSpecifier(commandLineUrl: string, relativePattern?: string): CollectorSpecifier;
-export declare class OriginSourcePattern {
-    private readonly include;
-    private readonly exclude;
-    private readonly includeMatches;
-    private readonly excludeMatches;
-    private readonly neitherExcludedNorIncluded;
-    constructor(include: string[] | undefined, exclude: string[] | undefined);
-    isIncluded(originFile: string): boolean;
-    isAnyIncluded(originFiles: string[]): boolean;
-    retrieveMatchingFiles(): {
-        includePatterns: string[];
-        excludePatterns: string[];
-        excludeMatches: string[];
-        includeMatches: string[];
-        neitherExcludedNorIncluded: string[];
-    };
-    patternsSpecified(): boolean;
-}
-export declare class FileExcludePattern {
-    private readonly exclude;
-    constructor(exclude: string[] | undefined);
-    isExcluded(filePath: string): boolean;
-}
-export declare class InstrumentationTask {
-    readonly collector: CollectorSpecifier;
-    readonly targetBucket: CoverageBucketSpecifier;
-    private readonly _elements;
-    readonly originSourcePattern: OriginSourcePattern;
-    readonly excludeFilesPattern: FileExcludePattern;
-    readonly dumpOriginsFile: string | undefined;
-    readonly dumpMatchedOriginsFile: string | undefined;
-    constructor(collector: CollectorSpecifier, targetBucket: CoverageBucketSpecifier, elements: TaskElement[], excludeFilesPattern: FileExcludePattern, originSourcePattern: OriginSourcePattern, dumpOriginsFile: string | undefined, dumpMatchedOriginsFile: string | undefined);
-    get elements(): TaskElement[];
-}
-export declare class TaskResult {
-    readonly translated: number;
-    readonly excluded: number;
-    readonly translatedFromCache: number;
-    readonly alreadyInstrumented: number;
-    readonly unsupported: number;
-    readonly failed: number;
-    readonly warnings: number;
-    readonly task?: InstrumentationTask;
-    constructor(translated: number, excluded: number, translatedFromCache: number, alreadyInstrumented: number, unsupported: number, failed: number, warnings: number, task?: InstrumentationTask);
-    withIncrement(incBy: TaskResult): TaskResult;
-    static neutral(task?: InstrumentationTask): TaskResult;
-    static error(e: Error): TaskResult;
-    static warning(msg: string): TaskResult;
-}
-export declare class SourceMapFileReference extends SourceMapReference {
-    readonly sourceMapFilePath: string;
-    constructor(sourceMapFilePath: string);
-}
-export {};
-//# sourceMappingURL=Task.d.ts.map