@tsdi/pack/es2015/ts-complie.js

@tsdi/pack is simple build tasks, base on AOP, Ioc container, via @tsdi. dev build pack activities.

import { __decorate } from "tslib";
import { Injectable } from '@tsdi/ioc';
import { iocAnnotations } from '@tsdi/annotations';
import { sys, createSourceFile, ScriptTarget, createProgram, DiagnosticCategory, formatDiagnostics, convertCompilerOptionsFromJson, readConfigFile, parseJsonConfigFileContent, transpileModule, createCompilerHost, ScriptKind, } from 'typescript';
import * as path from 'path';
import { tsdexp, jsFileExp, mapexp } from './exps';
let TsComplie = class TsComplie {
    compile(options, fileName, sourceText, annotation) {
        const host = createCompilerHost(options);
        const outputs = new Map();
        console.log(fileName);
        const tempSourceFile = createSourceFile(fileName, annotation ? iocAnnotations(sourceText) : sourceText, ScriptTarget.Latest, false, ScriptKind.TS);
        host.getSourceFile = (name, languageVersion, error) => {
            if (name === fileName) {
                return tempSourceFile;
            }
        };
        host.writeFile = (fileName, contents) => outputs.set(fileName, contents);
        const old = this.program;
        const program = this.program = createProgram([fileName], options, host, old);
        const emitResult = program.emit();
        const allDiagnostics = program.getSyntacticDiagnostics(tempSourceFile).concat(emitResult.diagnostics);
        if (!this.validateDiagnostics(allDiagnostics, true)) {
            return {
                code: null,
                map: null,
                emitSkipped: true,
            };
        }
        let emitSkipped = emitResult.emitSkipped;
        let code, map = null, dts;
        outputs.forEach((source, f) => {
            if (tsdexp.test(f)) {
                dts = source;
            }
            else if (jsFileExp.test(f)) {
                code = source;
            }
            else if (mapexp.test(f)) {
                map = source;
            }
        });
        outputs.clear();
        return { code, map, dts, emitSkipped };
    }
    transpileModule(compilerOptions, fileName, code, annotation) {
        const transformed = transpileModule(annotation ? iocAnnotations(code) : code, {
            fileName: fileName,
            reportDiagnostics: true,
            compilerOptions,
            transformers: {
                afterDeclarations: []
            }
        });
        // All errors except `Cannot compile modules into 'es6' when targeting 'ES5' or lower.`
        const diagnostics = transformed.diagnostics ?
            transformed.diagnostics.filter(diagnostic => diagnostic.code !== 1204) : [];
        if (!this.validateDiagnostics(diagnostics, true)) {
            throw new Error(`There were TypeScript errors transpiling`);
        }
        return {
            code: transformed.outputText,
            // Rollup expects `map` to be an object so we must parse the string
            map: transformed.sourceMapText ? JSON.parse(transformed.sourceMapText) : null
        };
    }
    parseTsconfig(projectDirectory, tsconfig, settings) {
        let compilerOptions;
        // let projectReferences: ReadonlyArray<ProjectReference>;
        const settingsResult = convertCompilerOptionsFromJson(settings || {}, projectDirectory);
        // if (settingsResult.errors) {
        //     throw settingsResult.errors;
        // }
        compilerOptions = settingsResult.options;
        let tsConfig = readConfigFile(tsconfig, sys.readFile);
        if (tsConfig.error) {
            console.log(tsConfig.error.messageText);
        }
        let parsed = parseJsonConfigFileContent(tsConfig.config || {}, this.getTsconfigSystem(sys), path.resolve(projectDirectory), compilerOptions, tsconfig);
        this.validateDiagnostics(parsed.errors);
        return parsed;
    }
    getTsconfigSystem(sys) {
        return {
            useCaseSensitiveFileNames: sys.useCaseSensitiveFileNames,
            readDirectory: () => [],
            fileExists: sys.fileExists,
            readFile: sys.readFile
        };
    }
    validateDiagnostics(diagnostics, strict) {
        // Print error diagnostics.
        const hasError = diagnostics.some(diag => diag.category === DiagnosticCategory.Error);
        if (hasError) {
            // Throw only if we're in strict mode, otherwise return original content.
            if (strict) {
                const errorMessages = formatDiagnostics(diagnostics, {
                    getCurrentDirectory: () => sys.getCurrentDirectory(),
                    getNewLine: () => sys.newLine,
                    getCanonicalFileName: (f) => f,
                });
                throw new Error(`
              TS failed with the following error messages:
              ${errorMessages}
            `);
            }
            else {
                return false;
            }
        }
        return true;
    }
    static ρAnn() {
        return { "name": "TsComplie", "params": { "compile": ["options", "fileName", "sourceText", "annotation"], "transpileModule": ["compilerOptions", "fileName", "code", "annotation"], "parseTsconfig": ["projectDirectory", "tsconfig", "settings"], "getTsconfigSystem": ["sys"], "validateDiagnostics": ["diagnostics", "strict"] } };
    }
};
TsComplie = __decorate([
    Injectable()
], TsComplie);
export { TsComplie };

//# sourceMappingURL=sourcemaps/ts-complie.js.map