@wdio/reporter 8.15.0 → 8.15.6

package/cjs/constants.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COLORS = void 0;
+exports.COLORS = {
+    pass: 90,
+    fail: 31,
+    'bright pass': 92,
+    'bright fail': 91,
+    'bright yellow': 93,
+    pending: 36,
+    suite: 0,
+    'error title': 0,
+    'error message': 31,
+    'error stack': 90,
+    checkmark: 32,
+    fast: 90,
+    medium: 33,
+    slow: 31,
+    green: 32,
+    light: 90,
+    'diff gutter': 90,
+    'diff added': 32,
+    'diff removed': 31,
+    'diff added inline': '30;42',
+    'diff removed inline': '30;41'
+};

package/cjs/index.js

@@ -0,0 +1,265 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunnerStats = exports.TestStats = exports.HookStats = exports.SuiteStats = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_events_1 = require("node:events");
+const logger_1 = __importDefault(require("@wdio/logger"));
+const utils_js_1 = require("./utils.js");
+const suite_js_1 = __importDefault(require("./stats/suite.js"));
+exports.SuiteStats = suite_js_1.default;
+const hook_js_1 = __importDefault(require("./stats/hook.js"));
+exports.HookStats = hook_js_1.default;
+const test_js_1 = __importDefault(require("./stats/test.js"));
+exports.TestStats = test_js_1.default;
+const runner_js_1 = __importDefault(require("./stats/runner.js"));
+exports.RunnerStats = runner_js_1.default;
+const log = (0, logger_1.default)('WDIOReporter');
+class WDIOReporter extends node_events_1.EventEmitter {
+    options;
+    outputStream;
+    failures = 0;
+    suites = {};
+    hooks = {};
+    tests = {};
+    currentSuites = [];
+    counts = {
+        suites: 0,
+        tests: 0,
+        hooks: 0,
+        passes: 0,
+        skipping: 0,
+        failures: 0
+    };
+    retries = 0;
+    runnerStat;
+    isContentPresent = false;
+    specs = [];
+    currentSpec;
+    constructor(options) {
+        super();
+        this.options = options;
+        // ensure the report directory exists
+        if (this.options.outputDir) {
+            try {
+                node_fs_1.default.mkdirSync(this.options.outputDir, { recursive: true });
+            }
+            catch (err) {
+                log.error(`Couldn't create output dir: ${err.stack}`);
+            }
+        }
+        this.outputStream = (this.options.stdout || !this.options.logFile) && this.options.writeStream
+            ? this.options.writeStream
+            : node_fs_1.default.createWriteStream(this.options.logFile);
+        let currentTest;
+        const rootSuite = new suite_js_1.default({
+            title: '(root)',
+            fullTitle: '(root)',
+            file: ''
+        });
+        this.currentSuites.push(rootSuite);
+        this.on('client:beforeCommand', this.onBeforeCommand.bind(this));
+        this.on('client:afterCommand', this.onAfterCommand.bind(this));
+        this.on('runner:start', /* istanbul ignore next */ (runner) => {
+            rootSuite.cid = runner.cid;
+            this.specs.push(...runner.specs);
+            this.runnerStat = new runner_js_1.default(runner);
+            this.onRunnerStart(this.runnerStat);
+        });
+        this.on('suite:start', /* istanbul ignore next */ (params) => {
+            /**
+             * the jasmine framework doesn't give us information about the file
+             * therefore we need to propagate these information into params
+             */
+            if (!params.file) {
+                params.file = !params.parent
+                    ? this.specs.shift() || 'unknown spec file'
+                    : this.currentSpec;
+                this.currentSpec = params.file;
+            }
+            const suite = new suite_js_1.default(params);
+            const currentSuite = this.currentSuites[this.currentSuites.length - 1];
+            currentSuite.suites.push(suite);
+            this.currentSuites.push(suite);
+            this.suites[suite.uid] = suite;
+            this.onSuiteStart(suite);
+        });
+        this.on('hook:start', /* istanbul ignore next */ (hook) => {
+            const hookStats = new hook_js_1.default(hook);
+            const currentSuite = this.currentSuites[this.currentSuites.length - 1];
+            currentSuite.hooks.push(hookStats);
+            currentSuite.hooksAndTests.push(hookStats);
+            this.hooks[hook.uid] = hookStats;
+            this.onHookStart(hookStats);
+        });
+        this.on('hook:end', /* istanbul ignore next */ (hook) => {
+            const hookStats = this.hooks[hook.uid];
+            hookStats.complete((0, utils_js_1.getErrorsFromEvent)(hook));
+            this.counts.hooks++;
+            this.onHookEnd(hookStats);
+        });
+        this.on('test:start', /* istanbul ignore next */ (test) => {
+            test.retries = this.retries;
+            currentTest = new test_js_1.default(test);
+            const currentSuite = this.currentSuites[this.currentSuites.length - 1];
+            currentSuite.tests.push(currentTest);
+            currentSuite.hooksAndTests.push(currentTest);
+            this.tests[test.uid] = currentTest;
+            this.onTestStart(currentTest);
+        });
+        this.on('test:pass', /* istanbul ignore next */ (test) => {
+            const testStat = this.tests[test.uid];
+            testStat.pass();
+            this.counts.passes++;
+            this.counts.tests++;
+            this.onTestPass(testStat);
+        });
+        this.on('test:skip', (test) => {
+            const testStat = this.tests[test.uid];
+            currentTest.skip(test.pendingReason);
+            this.counts.skipping++;
+            this.counts.tests++;
+            this.onTestSkip(testStat);
+        });
+        this.on('test:fail', /* istanbul ignore next */ (test) => {
+            const testStat = this.tests[test.uid];
+            testStat.fail((0, utils_js_1.getErrorsFromEvent)(test));
+            this.counts.failures++;
+            this.counts.tests++;
+            this.onTestFail(testStat);
+        });
+        this.on('test:retry', (test) => {
+            const testStat = this.tests[test.uid];
+            testStat.fail((0, utils_js_1.getErrorsFromEvent)(test));
+            this.onTestRetry(testStat);
+            this.retries++;
+        });
+        this.on('test:pending', (test) => {
+            test.retries = this.retries;
+            const currentSuite = this.currentSuites[this.currentSuites.length - 1];
+            currentTest = new test_js_1.default(test);
+            /**
+             * In Mocha: tests that are skipped don't have a start event but a test end.
+             * In Jasmine: tests have a start event, therefore we need to replace the
+             * test instance with the pending test here
+             */
+            if (test.uid in this.tests && this.tests[test.uid].state !== 'pending') {
+                currentTest.uid = test.uid in this.tests ? 'skipped-' + this.counts.skipping : currentTest.uid;
+            }
+            const suiteTests = currentSuite.tests;
+            if (!suiteTests.length || currentTest.uid !== suiteTests[suiteTests.length - 1].uid) {
+                currentSuite.tests.push(currentTest);
+                currentSuite.hooksAndTests.push(currentTest);
+            }
+            else {
+                suiteTests[suiteTests.length - 1] = currentTest;
+                currentSuite.hooksAndTests[currentSuite.hooksAndTests.length - 1] = currentTest;
+            }
+            this.tests[currentTest.uid] = currentTest;
+            currentTest.skip(test.pendingReason);
+            this.counts.skipping++;
+            this.counts.tests++;
+            this.onTestSkip(currentTest);
+        });
+        this.on('test:end', /* istanbul ignore next */ (test) => {
+            const testStat = this.tests[test.uid];
+            this.retries = 0;
+            this.onTestEnd(testStat);
+        });
+        this.on('suite:end', /* istanbul ignore next */ (suite) => {
+            const suiteStat = this.suites[suite.uid];
+            suiteStat.complete();
+            this.currentSuites.pop();
+            this.onSuiteEnd(suiteStat);
+        });
+        this.on('runner:end', /* istanbul ignore next */ (runner) => {
+            rootSuite.complete();
+            if (this.runnerStat) {
+                this.runnerStat.failures = runner.failures;
+                this.runnerStat.retries = runner.retries;
+                this.runnerStat.complete();
+                this.onRunnerEnd(this.runnerStat);
+            }
+            const logFile = this.options.logFile;
+            if (!this.isContentPresent && logFile && node_fs_1.default.existsSync(logFile)) {
+                node_fs_1.default.unlinkSync(logFile);
+            }
+        });
+        /**
+         * browser client event handlers
+         */
+        this.on('client:beforeCommand', /* istanbul ignore next */ (payload) => {
+            if (!currentTest) {
+                return;
+            }
+            currentTest.output.push(Object.assign(payload, { type: 'command' }));
+        });
+        this.on('client:afterCommand', /* istanbul ignore next */ (payload) => {
+            if (!currentTest) {
+                return;
+            }
+            currentTest.output.push(Object.assign(payload, { type: 'result' }));
+        });
+    }
+    /**
+     * allows reporter to stale process shutdown process until required sync work
+     * is done (e.g. when having to send data to some server or any other async work)
+     */
+    get isSynchronised() {
+        return true;
+    }
+    /**
+     * function to write to reporters output stream
+     */
+    write(content) {
+        if (content) {
+            this.isContentPresent = true;
+        }
+        this.outputStream.write(content);
+    }
+    /* istanbul ignore next */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    onRunnerStart(runnerStats) { }
+    /* istanbul ignore next */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    onBeforeCommand(commandArgs) { }
+    /* istanbul ignore next */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    onAfterCommand(commandArgs) { }
+    /* istanbul ignore next */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    onSuiteStart(suiteStats) { }
+    /* istanbul ignore next */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    onHookStart(hookStat) { }
+    /* istanbul ignore next */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    onHookEnd(hookStats) { }
+    /* istanbul ignore next */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    onTestStart(testStats) { }
+    /* istanbul ignore next */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    onTestPass(testStats) { }
+    /* istanbul ignore next */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    onTestFail(testStats) { }
+    /* istanbul ignore next */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    onTestRetry(testStats) { }
+    /* istanbul ignore next */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    onTestSkip(testStats) { }
+    /* istanbul ignore next */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    onTestEnd(testStats) { }
+    /* istanbul ignore next */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    onSuiteEnd(suiteStats) { }
+    /* istanbul ignore next */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    onRunnerEnd(runnerStats) { }
+}
+exports.default = WDIOReporter;

package/cjs/stats/hook.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const runnable_js_1 = __importDefault(require("./runnable.js"));
+class HookStats extends runnable_js_1.default {
+    uid;
+    cid;
+    title;
+    parent;
+    // Mocha only
+    body;
+    errors;
+    error;
+    state;
+    currentTest;
+    constructor(runner) {
+        super('hook');
+        this.uid = runnable_js_1.default.getIdentifier(runner);
+        this.cid = runner.cid;
+        this.title = runner.title;
+        this.parent = runner.parent;
+        this.currentTest = runner.currentTest;
+        this.body = runner.body;
+    }
+    complete(errors) {
+        this.errors = errors;
+        if (errors && errors.length) {
+            this.error = errors[0];
+            this.state = 'failed';
+        }
+        super.complete();
+    }
+}
+exports.default = HookStats;

package/cjs/stats/runnable.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Main class for a runnable class (e.g. test, suite or a hook)
+ * mainly used to capture its running duration
+ */
+class RunnableStats {
+    type;
+    start = new Date();
+    end;
+    _duration = 0;
+    constructor(type) {
+        this.type = type;
+    }
+    complete() {
+        this.end = new Date();
+        this._duration = this.end.getTime() - this.start.getTime();
+    }
+    get duration() {
+        if (this.end) {
+            return this._duration;
+        }
+        return new Date().getTime() - this.start.getTime();
+    }
+    /**
+     * ToDo: we should always rely on uid
+     */
+    static getIdentifier(runner) {
+        return runner.uid || runner.title;
+    }
+}
+exports.default = RunnableStats;

package/cjs/stats/runner.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const runnable_js_1 = __importDefault(require("./runnable.js"));
+const utils_js_1 = require("../utils.js");
+/**
+ * Class to capture statistics about a test run. A test run is a single instance that
+ * runs one or more spec files
+ */
+class RunnerStats extends runnable_js_1.default {
+    cid;
+    capabilities;
+    sanitizedCapabilities;
+    config;
+    specs;
+    sessionId;
+    isMultiremote;
+    instanceOptions;
+    retry;
+    failures;
+    retries;
+    constructor(runner) {
+        super('runner');
+        this.cid = runner.cid;
+        this.capabilities = runner.capabilities;
+        this.sanitizedCapabilities = (0, utils_js_1.sanitizeCaps)(runner.capabilities);
+        this.config = runner.config;
+        this.specs = runner.specs;
+        this.sessionId = runner.sessionId;
+        this.isMultiremote = runner.isMultiremote;
+        this.instanceOptions = runner.instanceOptions;
+        this.retry = runner.retry;
+    }
+}
+exports.default = RunnerStats;

package/cjs/stats/suite.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const runnable_js_1 = __importDefault(require("./runnable.js"));
+/**
+ * Class describing statistics about a single suite.
+ */
+class SuiteStats extends runnable_js_1.default {
+    uid;
+    cid;
+    file;
+    title;
+    fullTitle;
+    tags;
+    tests = [];
+    hooks = [];
+    suites = [];
+    parent;
+    /**
+     * an array of hooks and tests stored in order as they happen
+     */
+    hooksAndTests = [];
+    description;
+    rule;
+    constructor(suite) {
+        super(suite.type || 'suite');
+        this.uid = runnable_js_1.default.getIdentifier(suite);
+        this.cid = suite.cid;
+        this.file = suite.file;
+        this.title = suite.title;
+        this.fullTitle = suite.fullTitle;
+        this.tags = suite.tags;
+        this.parent = suite.parent;
+        /**
+         * only Cucumber
+         */
+        this.description = suite.description;
+        this.rule = suite.rule;
+    }
+}
+exports.default = SuiteStats;

package/cjs/stats/test.js

@@ -0,0 +1,114 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_util_1 = require("node:util");
+const diff_1 = require("diff");
+const object_inspect_1 = __importDefault(require("object-inspect"));
+const runnable_js_1 = __importDefault(require("./runnable.js"));
+const utils_js_1 = require("../utils.js");
+const maxStringLength = 2048;
+/**
+ * TestStats class
+ * captures data on a test.
+ */
+class TestStats extends runnable_js_1.default {
+    uid;
+    cid;
+    title;
+    currentTest;
+    fullTitle;
+    output;
+    argument;
+    retries;
+    parent;
+    /**
+     * initial test state is pending
+     * the state can change to the following: passed, skipped, failed
+     */
+    state;
+    pendingReason;
+    errors;
+    error;
+    body;
+    constructor(test) {
+        super('test');
+        this.uid = runnable_js_1.default.getIdentifier(test);
+        this.cid = test.cid;
+        this.title = test.title;
+        this.fullTitle = test.fullTitle;
+        this.output = [];
+        this.argument = test.argument;
+        this.retries = test.retries;
+        this.parent = test.parent;
+        // Mocha only
+        this.body = test.body;
+        /**
+         * initial test state is pending
+         * the state can change to the following: passed, skipped, failed
+         */
+        this.state = 'pending';
+    }
+    pass() {
+        this.complete();
+        this.state = 'passed';
+    }
+    skip(reason) {
+        this.pendingReason = reason;
+        this.state = 'skipped';
+    }
+    fail(errors) {
+        this.complete();
+        this.state = 'failed';
+        /**
+         * Iterates through all errors to check if they're a type of 'AssertionError',
+         * and formats it if so. Otherwise, just leaves error as is
+         */
+        const formattedErrors = errors?.map((err) => (
+        /**
+         * only format if error object has either an "expected" or "actual" property set
+         */
+        ((err.expected || err.actual) && !node_util_1.types.isProxy(err.actual)) &&
+            /**
+             * and if they aren't already formated, e.g. in Jasmine
+             */
+            (err.message && !err.message.includes('Expected: ') && !err.message.includes('Received: '))
+            ? this._stringifyDiffObjs(err)
+            : err));
+        this.errors = formattedErrors;
+        if (formattedErrors && formattedErrors.length) {
+            this.error = formattedErrors[0];
+        }
+    }
+    _stringifyDiffObjs(err) {
+        const inspectOpts = { maxStringLength };
+        const expected = (0, object_inspect_1.default)(err.expected, inspectOpts);
+        const actual = (0, object_inspect_1.default)(err.actual, inspectOpts);
+        let msg = (0, diff_1.diffWordsWithSpace)(actual, expected)
+            .map((str) => (str.added
+            ? (0, utils_js_1.colorLines)('diff added inline', str.value)
+            : str.removed
+                ? (0, utils_js_1.colorLines)('diff removed inline', str.value)
+                : str.value))
+            .join('');
+        // linenos
+        const lines = msg.split('\n');
+        if (lines.length > 4) {
+            const width = String(lines.length).length;
+            msg = lines
+                .map(function (str, i) {
+                return (0, utils_js_1.pad)(String(++i), width) + ' |' + ' ' + str;
+            })
+                .join('\n');
+        }
+        // legend
+        msg = `\n${(0, utils_js_1.color)('diff removed inline', 'actual')} ${(0, utils_js_1.color)('diff added inline', 'expected')}\n\n${msg}\n`;
+        // indent
+        msg = msg.replace(/^/gm, '      ');
+        const newError = new Error(err.message + msg);
+        newError.stack = err.stack;
+        return newError;
+    }
+}
+exports.default = TestStats;

package/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/utils.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.colorLines = exports.color = exports.pad = exports.getErrorsFromEvent = exports.sanitizeCaps = exports.sanitizeString = void 0;
+const supports_color_1 = __importDefault(require("supports-color"));
+const constants_js_1 = require("./constants.js");
+/**
+ * replaces whitespaces with underscore and removes dots
+ * @param  {string} str  variable to sanitize
+ * @return {String}      sanitized variable
+ */
+function sanitizeString(str) {
+    if (!str) {
+        return '';
+    }
+    return String(str)
+        .replace(/^.*\/([^/]+)\/?$/, '$1')
+        .replace(/\./g, '_')
+        .replace(/\s/g, '')
+        .toLowerCase();
+}
+exports.sanitizeString = sanitizeString;
+/**
+ * formats capability object into sanitized string for e.g.filenames
+ * @param {object} caps  Selenium capabilities
+ */
+function sanitizeCaps(caps) {
+    if (!caps) {
+        return '';
+    }
+    let result;
+    /**
+     * mobile caps
+     */
+    result = caps.deviceName
+        ? [
+            sanitizeString(caps.platformName),
+            sanitizeString(caps.deviceName || caps['appium:deviceName']),
+            sanitizeString(caps['appium:platformVersion']),
+            sanitizeString(caps['appium:app'])
+        ]
+        : [
+            sanitizeString(caps.browserName),
+            sanitizeString(caps.version || caps.browserVersion),
+            sanitizeString(caps.platform || caps.platformName),
+            sanitizeString(caps['appium:app'])
+        ];
+    result = result.filter(n => n !== undefined && n !== '');
+    return result.join('.');
+}
+exports.sanitizeCaps = sanitizeCaps;
+/**
+ * Takes a event emitted by a framework and extracts
+ * an array of errors representing test or hook failures.
+ * This exists to maintain compatibility between frameworks
+ * with have a soft assertion model (Jasmine) and those that
+ * have a hard assertion model (Mocha)
+ * @param {*} e  An event emitted by a framework adapter
+ */
+function getErrorsFromEvent(e) {
+    if (e.errors) {
+        return e.errors;
+    }
+    if (e.error) {
+        return [e.error];
+    }
+    return [];
+}
+exports.getErrorsFromEvent = getErrorsFromEvent;
+/**
+ * Pads the given `str` to `len`.
+ *
+ * @private
+ * @param {string} str
+ * @param {number} len
+ * @return {string}
+ */
+function pad(str, len) {
+    return Array(len - str.length + 1).join(' ') + str;
+}
+exports.pad = pad;
+function color(type, content) {
+    if (!supports_color_1.default.stdout) {
+        return String(content);
+    }
+    return `\u001b[${constants_js_1.COLORS[type]}m${content}\u001b[0m`;
+}
+exports.color = color;
+/**
+ * Colors lines for `str`, using the color `name`.
+ *
+ * @private
+ * @param {string} name
+ * @param {string} str
+ * @return {string}
+ */
+function colorLines(name, str) {
+    return str
+        .split('\n')
+        .map((str) => color(name, str))
+        .join('\n');
+}
+exports.colorLines = colorLines;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wdio/reporter",
-  "version": "8.15.0",
+  "version": "8.15.6",
   "description": "A WebdriverIO utility to help reporting all events",
   "author": "Christian Bromann <mail@bromann.dev>",
   "homepage": "https://github.com/webdriverio/webdriverio/tree/main/packages/wdio-reporter",
@@ -25,10 +25,19 @@
     "access": "public"
   },
   "type": "module",
+  "main": "./cjs/index.js",
+  "module": "./build/index.js",
   "types": "./build/index.d.ts",
   "exports": {
-    ".": "./build/index.js",
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    ".": [
+      {
+        "types": "./build/index.d.ts",
+        "import": "./build/index.js",
+        "require": "./cjs/index.js"
+      },
+      "./cjs/index.js"
+    ]
   },
   "typeScriptVersion": "3.8.3",
   "dependencies": {
@@ -46,5 +55,5 @@
     "@types/tmp": "^0.2.3",
     "tmp": "^0.2.1"
   },
-  "gitHead": "78e199c5ffd74bdf3a5576952c3834c29afa989f"
+  "gitHead": "c205398c7773823b1eb365a5abeadbcc2fb6b8a3"
 }

package/tsconfig.cjs.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.prod.json",
+  "compilerOptions": {
+    "module": "CommonJS",
+    "outDir": "./cjs",
+    "declaration": false,
+    "declarationMap": false
+  }
+}