@tsdi/pack/es2015/transforms/TsBuildActivity.js

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

import { __awaiter, __decorate, __metadata } from "tslib";
import { isString } from '@tsdi/ioc';
import { Input } from '@tsdi/components';
import { Task, Activities } from '@tsdi/activities';
import { AssetActivity } from './AssetActivity';
import { isTransform } from '../ITransform';
const sourcemaps = require('gulp-sourcemaps');
const ts = require('gulp-typescript');
let TsBuildActivity = class TsBuildActivity extends AssetActivity {
    static ρAnn() {
        return { "name": "TsBuildActivity", "params": {} };
    }
};
__decorate([
    Input(),
    __metadata("design:type", Object)
], TsBuildActivity.prototype, "dts", void 0);
__decorate([
    Input(),
    __metadata("design:type", Object)
], TsBuildActivity.prototype, "annotation", void 0);
__decorate([
    Input('annotationFramework'),
    __metadata("design:type", Object)
], TsBuildActivity.prototype, "annotationFramework", void 0);
__decorate([
    Input('beforePipes'),
    __metadata("design:type", Array)
], TsBuildActivity.prototype, "beforePipes", void 0);
__decorate([
    Input('tsconfig', './tsconfig.json'),
    __metadata("design:type", Object)
], TsBuildActivity.prototype, "tsconfig", void 0);
__decorate([
    Input(),
    __metadata("design:type", Object)
], TsBuildActivity.prototype, "uglify", void 0);
__decorate([
    Input('uglifyOptions'),
    __metadata("design:type", Object)
], TsBuildActivity.prototype, "uglifyOptions", void 0);
TsBuildActivity = __decorate([
    Task({
        selector: 'ts',
        template: [
            {
                activity: 'src',
                src: 'binding: src',
            },
            {
                activity: 'annotation',
                annotationFramework: 'binding: annotationFramework',
                annotation: 'binding: annotation'
            },
            {
                activity: Activities.if,
                condition: 'binding: sourcemap',
                body: {
                    name: 'sourcemap-init',
                    activity: Activities.execute,
                    action: (ctx, bind) => {
                        let scope = bind.getScope();
                        let framework = scope.framework || sourcemaps;
                        return ctx.getData().pipe(framework.init());
                    }
                }
            },
            {
                activity: Activities.if,
                condition: (ctx, bind) => { var _a; return ((_a = bind.getScope().beforePipes) === null || _a === void 0 ? void 0 : _a.length) > 0; },
                body: {
                    activity: 'pipes',
                    pipes: 'binding: beforePipes'
                }
            },
            {
                activity: Activities.execute,
                name: 'tscompile',
                action: (ctx, bind) => __awaiter(void 0, void 0, void 0, function* () {
                    let scope = bind.getScope();
                    if (!scope.tsconfig) {
                        return;
                    }
                    let tsconfig = yield ctx.resolveExpression(scope.tsconfig);
                    let tsCompile;
                    let dts = yield ctx.resolveExpression(scope.dts);
                    if (isString(tsconfig)) {
                        let tsProject = ts.createProject(ctx.platform.relativeRoot(tsconfig), { declaration: !!dts });
                        tsCompile = tsProject();
                    }
                    else {
                        tsconfig.declaration = !!dts;
                        let tsProject = ts.createProject(ctx.platform.relativeRoot('./tsconfig.json'), tsconfig);
                        tsCompile = tsProject();
                    }
                    return ctx.getData().pipe(tsCompile);
                })
            },
            {
                activity: Activities.if,
                externals: {
                    data: 'ctx.getData() | tsjs'
                },
                condition: ctx => isTransform(ctx.getData()),
                body: [
                    {
                        activity: 'pipes',
                        pipes: 'binding: pipes'
                    },
                    {
                        activity: 'if',
                        condition: 'binding: uglify',
                        body: {
                            activity: 'uglify',
                            uglifyOptions: 'binding: uglifyOptions'
                        }
                    },
                    {
                        activity: Activities.if,
                        condition: 'binding: sourcemap',
                        body: {
                            name: 'sourcemap-write',
                            activity: Activities.execute,
                            action: (ctx, bind) => __awaiter(void 0, void 0, void 0, function* () {
                                let scope = bind.getScope();
                                let framework = scope.framework || sourcemaps;
                                return ctx.getData().pipe(framework.write(isString(scope.sourcemap) ? scope.sourcemap : './sourcemaps'));
                            })
                        }
                    },
                    {
                        name: 'write-js',
                        activity: 'dist',
                        dist: 'binding: dist'
                    }
                ]
            },
            {
                activity: Activities.if,
                externals: {
                    data: 'ctx.getData() | dts'
                },
                condition: 'binding: dts',
                body: {
                    name: 'write-dts',
                    activity: 'dist',
                    dist: 'binding: dts'
                }
            }
        ]
    })
], TsBuildActivity);
export { TsBuildActivity };

//# sourceMappingURL=../sourcemaps/transforms/TsBuildActivity.js.map