"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var lodash = require("lodash");
var log4js = require("log4js");
var lodash_1 = require("lodash");
var Configuration = /** @class */ (function () {
    function Configuration(loggers) {
        this.loggers = loggers;
        this.callbacks = [];
    }
    Configuration.prototype.initialize = function (config) {
        this.karma = config || {};
        this.karmaTypescriptConfig = config.karmaTypescriptConfig || {};
        this.configureLogging();
        this.configureBundler();
        this.configureCoverage();
        this.configureProject();
        this.configurePreprocessor();
        this.configureReporter();
        this.configureKarmaCoverage();
        this.assertConfiguration();
        for (var _i = 0, _a = this.callbacks; _i < _a.length; _i++) {
            var callback = _a[_i];
            callback();
        }
    };
    Configuration.prototype.whenReady = function (callback) {
        this.callbacks.push(callback);
    };
    Configuration.prototype.hasFramework = function (name) {
        return this.karma.frameworks.indexOf(name) !== -1;
    };
    Configuration.prototype.hasPreprocessor = function (name) {
        for (var preprocessor in this.karma.preprocessors) {
            if (this.karma.preprocessors[preprocessor] &&
                this.karma.preprocessors[preprocessor].indexOf(name) !== -1) {
                return true;
            }
        }
        return false;
    };
    Configuration.prototype.hasReporter = function (name) {
        return this.karma.reporters.indexOf(name) !== -1;
    };
    Configuration.prototype.configureLogging = function () {
        var _this = this;
        this.logAppenders = this.karma.loggers instanceof Array
            ? this.karma.loggers.reduce(function (logAppenders, logger, index) {
                var _a;
                return Object.assign(logAppenders, (_a = {}, _a[logger.type + index] = logger, _a));
            }, {})
            : this.karma.loggers;
        if (this.logAppenders != null) {
            log4js.configure({
                appenders: this.logAppenders,
                categories: {
                    default: {
                        appenders: Object.keys(this.logAppenders),
                        level: this.karma.logLevel
                    }
                }
            });
        }
        Object.keys(this.loggers).forEach(function (key) {
            _this.loggers[key].level = _this.karma.logLevel;
        });
    };
    Configuration.prototype.configureBundler = function () {
        var defaultBundlerOptions = {
            acornOptions: {
                ecmaVersion: 7,
                sourceType: "module"
            },
            addNodeGlobals: true,
            constants: {},
            entrypoints: /.*/,
            exclude: [],
            ignore: [],
            noParse: [],
            resolve: {
                alias: {},
                directories: ["node_modules"],
                extensions: [".js", ".json", ".ts", ".tsx"]
            },
            sourceMap: false,
            transforms: [],
            validateSyntax: true
        };
        this.bundlerOptions = lodash_1.merge(defaultBundlerOptions, this.karmaTypescriptConfig.bundlerOptions);
    };
    Configuration.prototype.configureCoverage = function () {
        var defaultCoverageOptions = {
            exclude: /\.(d|spec|test)\.ts$/i,
            instrumentation: true,
            threshold: {
                file: {
                    branches: 0,
                    excludes: [],
                    functions: 0,
                    lines: 0,
                    overrides: {},
                    statements: 0
                },
                global: {
                    branches: 0,
                    excludes: [],
                    functions: 0,
                    lines: 0,
                    statements: 0
                }
            }
        };
        this.hasCoverageThreshold = !!this.karmaTypescriptConfig.coverageOptions &&
            !!this.karmaTypescriptConfig.coverageOptions.threshold;
        this.coverageOptions = lodash_1.merge(defaultCoverageOptions, this.karmaTypescriptConfig.coverageOptions);
        this.assertCoverageExclude(this.coverageOptions.exclude);
    };
    Configuration.prototype.configureProject = function () {
        this.compilerDelay = this.karmaTypescriptConfig.compilerDelay || 250;
        this.compilerOptions = this.karmaTypescriptConfig.compilerOptions;
        this.defaultTsconfig = {
            compilerOptions: {
                emitDecoratorMetadata: true,
                experimentalDecorators: true,
                jsx: "react",
                module: "commonjs",
                sourceMap: true,
                target: "ES5"
            },
            exclude: ["node_modules"]
        };
        this.exclude = this.karmaTypescriptConfig.exclude;
        this.include = this.karmaTypescriptConfig.include;
        this.tsconfig = this.karmaTypescriptConfig.tsconfig;
        this.assertExtendable("exclude");
        this.assertExtendable("include");
    };
    Configuration.prototype.configurePreprocessor = function () {
        var transformPath = function (filepath) {
            return filepath.replace(/\.(ts|tsx)$/, ".js");
        };
        this.transformPath = this.karmaTypescriptConfig.transformPath || transformPath;
    };
    Configuration.prototype.configureReporter = function () {
        this.reports = this.karmaTypescriptConfig.reports || { html: "coverage" };
        this.remapOptions = this.karmaTypescriptConfig.remapOptions || {};
    };
    Configuration.prototype.configureKarmaCoverage = function () {
        var defaultCoverageReporter = {
            instrumenterOptions: {
                istanbul: { noCompact: true }
            }
        };
        this.coverageReporter = lodash_1.merge(defaultCoverageReporter, this.karma.coverageReporter);
        if (Array.isArray(this.karma.reporters)) {
            this.reporters = this.karma.reporters.slice();
            if (this.karma.reporters.indexOf("coverage") === -1) {
                this.reporters.push("coverage");
            }
        }
        else {
            this.reporters = ["coverage"];
        }
    };
    Configuration.prototype.assertConfiguration = function () {
        if (!this.asserted) {
            this.asserted = true;
            this.assertFrameworkConfiguration();
            this.assertDeprecatedOptions();
        }
    };
    Configuration.prototype.assertFrameworkConfiguration = function () {
        if (this.hasPreprocessor("karma-typescript") &&
            (!this.karma.frameworks || this.karma.frameworks.indexOf("karma-typescript") === -1)) {
            throw new Error("Missing karma-typescript framework, please add" +
                "'frameworks: [\"karma-typescript\"]' to your Karma config");
        }
    };
    Configuration.prototype.assertExtendable = function (key) {
        var extendable = this[key];
        if (extendable === undefined) {
            return;
        }
        if (Array.isArray(extendable)) {
            extendable.forEach(function (item) {
                if (!lodash.isString(item)) {
                    throw new Error("Expected a string in 'karmaTypescriptConfig." + key + "', got [" +
                        typeof item + "]: " + item);
                }
            });
            return;
        }
        if (lodash.isObject(extendable)) {
            if (["merge", "replace"].indexOf(extendable.mode) === -1) {
                throw new Error("Expected 'karmaTypescriptConfig." + key + ".mode' to be 'merge|replace', got '" +
                    extendable.mode + "'");
            }
            if (Array.isArray(extendable.values)) {
                extendable.values.forEach(function (item) {
                    if (!lodash.isString(item)) {
                        throw new Error("Expected a string in 'karmaTypescriptConfig." + key + ".values', got [" +
                            typeof item + "]: " + item);
                    }
                });
            }
            return;
        }
        throw new Error("The option 'karmaTypescriptConfig." + key +
            "' must be an array of strings or { mode: \"replace|extend\", values: [string, string], got [" +
            typeof this.exclude + "]: " + this.exclude);
    };
    Configuration.prototype.assertDeprecatedOptions = function () {
        if (this.bundlerOptions.ignoredModuleNames) {
            throw new Error("The option 'karmaTypescriptConfig.bundlerOptions.ignoredModuleNames' has been " +
                "removed, please use 'karmaTypescriptConfig.bundlerOptions.exclude' instead");
        }
        if (this.karmaTypescriptConfig.excludeFromCoverage !== undefined) {
            throw new Error("The option 'karmaTypescriptConfig.excludeFromCoverage' has been " +
                "removed, please use 'karmaTypescriptConfig.coverageOptions.exclude' instead");
        }
        if (this.karmaTypescriptConfig.disableCodeCoverageInstrumentation !== undefined) {
            throw new Error("The option 'karmaTypescriptConfig.disableCodeCoverageInstrumentation' has been " +
                "removed, please use 'karmaTypescriptConfig.coverageOptions.instrumentation' instead");
        }
    };
    Configuration.prototype.assertCoverageExclude = function (regex) {
        var _this = this;
        if (regex instanceof RegExp || !regex) {
            return regex;
        }
        else if (Array.isArray(regex)) {
            regex.forEach(function (r) {
                if (!(r instanceof RegExp)) {
                    _this.throwCoverageExcludeError(r);
                }
            });
            return regex;
        }
        this.throwCoverageExcludeError(regex);
    };
    Configuration.prototype.throwCoverageExcludeError = function (regex) {
        throw new Error("karmaTypescriptConfig.coverageOptions.exclude " +
            "must be a single RegExp or an Array of RegExp, got [" + typeof regex + "]: " + regex);
    };
    return Configuration;
}());
exports.Configuration = Configuration;
//# sourceMappingURL=configuration.js.map