simplr-gulp/dist/builders/typescript/typescript-builder-compiler.js

Fully functional gulpfile.js implementation. Tailored for Single Page Application. Written in TypeScript.

Object.defineProperty(exports, "__esModule", { value: true });
const ts = require("gulp-typescript");
const paths_1 = require("../../paths/paths");
const path = require("path");
const logger_1 = require("../../utils/logger");
const helpers_1 = require("../../utils/helpers");
class TypescriptBuilderCompiler {
    constructor(configFile) {
        this.Project = this.createTsProject(configFile);
        let tsConfig = this.Project.config;
        this.setConfig(tsConfig);
    }
    setConfig(tsConfig) {
        this.Config = {};
        this.Config.RootDir = this.generateRootDir(tsConfig.compilerOptions['rootDir']);
        this.Config.OutDir = this.generateOutDir(tsConfig.compilerOptions['outDir']);
        this.Config.Include = this.generateInclude(tsConfig.include, this.Config.RootDir);
        this.Config.Exclude = this.generateExclude(tsConfig.exclude);
        this.Config.Src = this.generateSrc(this.Config.Include, this.Config.Exclude);
    }
    createTsProject(configFile) {
        let requiredTypescript = require("typescript");
        logger_1.LoggerInstance.withType("TS").info(`Using TypeScript@${requiredTypescript.version}`);
        return ts.createProject(configFile, {
            typescript: requiredTypescript
        });
    }
    generateSrc(include, exclude) {
        let results = include;
        if (exclude != null) {
            results = results.concat(exclude);
        }
        return results.map(src => {
            return helpers_1.FixSeparator(src);
        });
    }
    generateInclude(include, rootDir) {
        let results;
        if (include != null) {
            let resultInclude = include.map(inc => {
                if (inc !== undefined) {
                    if (path.extname(inc).length === 0) {
                        return this.addAvailableTsExtensions(inc);
                    }
                    else {
                        return inc;
                    }
                }
            }).filter(x => x != null);
            resultInclude = resultInclude.map(src => {
                return helpers_1.FixSeparator(src);
            });
            if (resultInclude.indexOf(rootDir) === -1) {
                resultInclude.push(rootDir);
            }
            results = resultInclude;
        }
        else {
            results = [helpers_1.FixSeparator(rootDir)];
        }
        return results;
    }
    generateExclude(exclude) {
        if (exclude != null) {
            let tempExclude = exclude.map(exc => {
                if (exc !== undefined) {
                    return `!${exc}`;
                }
            });
            if (tempExclude.length > 0) {
                let resultInclude = tempExclude.filter(x => x != null);
                if (tempExclude.length > 0) {
                    return resultInclude;
                }
            }
        }
        return undefined;
    }
    generateRootDir(rootDir) {
        if (rootDir != null) {
            return [rootDir, "**", `*${this.addAvailableTsExtensions()}`].join("/");
        }
        else {
            return paths_1.Paths.Builders.AllFiles.InSource(this.addAvailableTsExtensions());
        }
    }
    generateOutDir(outDir) {
        return outDir || paths_1.Paths.Directories.Build;
    }
    addAvailableTsExtensions(name = "") {
        return name + ".{ts,tsx}";
    }
}
exports.TypescriptBuilderCompiler = TypescriptBuilderCompiler;