@tsdi/pack
Version:
@tsdi/pack is simple build tasks, base on AOP, Ioc container, via @tsdi. dev build pack activities.
1,493 lines (1,464 loc) • 81.6 kB
JavaScript
import { isObject, isFunction, isObservable, tokenId, Injectable, Refs, isString, isArray, PromiseUtil, lang, isNullOrUndefined, isBoolean, isDefined, Inject } from '@tsdi/ioc';
import { Stream } from 'stream';
import { __decorate, __awaiter, __metadata } from 'tslib';
import { syncRequire, toAbsolutePath } from '@tsdi/platform-server';
import { readdirSync, lstatSync, existsSync } from 'fs';
import { basename, extname, normalize, join, dirname, relative, resolve as resolve$1 } from 'path';
import { rm, cp, mkdir } from 'shelljs';
import globby from 'globby';
import { BuildContext, DIModule } from '@tsdi/boot';
import { ActivityContext, Activity, Task, Activities } from '@tsdi/activities';
import { Input, Pipe } from '@tsdi/components';
import { exec } from 'child_process';
import { runTest } from '@tsdi/unit';
import { ConsoleReporter } from '@tsdi/unit-console';
import { fromEventPattern } from 'rxjs';
import { bufferTime, filter } from 'rxjs/operators';
import { rollup } from 'rollup';
import { createCompilerHost, createSourceFile, ScriptTarget, ScriptKind, createProgram, transpileModule, convertCompilerOptionsFromJson, readConfigFile, sys, parseJsonConfigFileContent, DiagnosticCategory, formatDiagnostics, nodeModuleNameResolver } from 'typescript';
import { createFilter } from 'rollup-pluginutils';
import { iocAnnotations, classAnnotations } from '@tsdi/annotations';
import { obj } from 'through2';
import { dest, src } from 'vinyl-fs';
import { ServerBootstrapModule } from '@tsdi/platform-server-boot';
/**
*check target is transform or not.
*
* @export
* @param {*} target
* @returns {boolean}
*/
function isTransform(target) {
return (isObject(target) === true) && (target instanceof Stream || (isFunction(target.pipe) && !isObservable(target)));
}
const PlatformServiceToken = tokenId('pack_PlatformService');
var NodeActivityContext_1;
/**
* pipe activity context.
*
* @export
* @class NodeActivityContext
* @extends {ActivityContext}
* @implements {IActivityContext<ITransform>}
*/
let NodeActivityContext = NodeActivityContext_1 = class NodeActivityContext extends ActivityContext {
get platform() {
var _a;
return (_a = this.context.getValue(PlatformServiceToken)) !== null && _a !== void 0 ? _a : this.getPlatform();
}
getPlatform() {
let pf = this.injector.getInstance(PlatformServiceToken, { provide: NodeActivityContext_1, useValue: this });
pf && this.setValue(PlatformServiceToken, pf);
return pf;
}
static ρAnn() {
return { "name": "NodeActivityContext", "params": {} };
}
};
NodeActivityContext = NodeActivityContext_1 = __decorate([
Injectable,
Refs(Activity, BuildContext)
], NodeActivityContext);
const minimist = require('minimist');
const del = require('del');
const relChkExp = /^(.{1,2}\/?\\?)?$/;
const notExp = /^!/;
const replNodeMdlExp = /(node_modules)[\\\/]/g;
let PlatformService = class PlatformService {
constructor(ctx) {
this.ctx = ctx;
this.packageFile = 'package.json';
}
/**
* get evn args.
*
* @returns {ObjectMap}
* @memberof NodeContext
*/
getEnvArgs() {
if (!this.envArgs) {
this.envArgs = minimist([...this.ctx.workflow.args, ...process.argv.slice(2)]);
}
return this.envArgs;
}
hasArg(arg) {
return process.argv.indexOf(arg) > -1 || process.argv.indexOf('--' + arg) > -1;
}
/**
* get root folders.
*
* @param {Express2<string, string, boolean>} [express]
* @returns {string[]}
* @memberof NodeContext
*/
getRootFolders(express) {
return this.getFolders(this.getRootPath(), express);
}
getCompilerOptions(tsconfig) {
let filename = this.toRootPath(tsconfig);
let cfg = syncRequire(filename) || {};
return cfg.compilerOptions || {};
}
getFileName(pathName) {
return basename(pathName).replace(extname(pathName), '');
}
/**
* get folders of path.
*
* @param {string} pathstr
* @param {Express2<string, string, boolean>} [express]
* @returns {string[]}
* @memberof NodeContext
*/
getFolders(pathstr, express) {
pathstr = normalize(pathstr);
let dir = readdirSync(pathstr);
let folders = [];
dir.forEach(d => {
let sf = join(pathstr, d);
let f = lstatSync(sf);
if (f.isDirectory()) {
if (express) {
let fl = express(sf, d);
if (fl) {
folders.push(fl);
}
}
else {
folders.push(sf);
}
}
});
return folders;
}
getFiles(express, options, filter, mapping) {
return __awaiter(this, void 0, void 0, function* () {
if (!(isString(express) || isArray(express))) {
throw Error('input express param type error!');
}
if (isFunction(options)) {
filter = options;
mapping = filter;
options = {};
}
let filePaths = (yield globby(this.normalizeSrc(express), options)).map(e => isString(e) ? e : e.path);
if (filter) {
filePaths = filePaths.filter(filter);
}
if (mapping) {
return filePaths.map(mapping);
}
return filePaths;
});
}
join(...paths) {
return join(...paths);
}
normalize(url) {
return url ? url.split('\\').join('/') : url;
}
normalizeSrc(src) {
if (isString(src)) {
return this.normalize(src);
}
else {
return src.map(s => this.normalize(s));
}
}
copyFile(src, dist, options) {
if (options && options.force) {
rm('-f', dist);
cp(src, dist);
}
else {
cp(src, dist);
}
}
existsFile(filename) {
return existsSync(this.toRootPath(filename));
}
copyDir(src, dist, options) {
if (!existsSync(dist)) {
mkdir('-p', dist);
}
if (options && options.force) {
rm('-rf', normalize(join(dist, '/')));
mkdir('-p', normalize(join(dist, '/')));
cp('-R', normalize(src + '/*'), normalize(join(dist, '/')));
}
else {
cp('-R', normalize(src + '/*'), normalize(join(dist, '/')));
}
}
copyTo(filePath, dist) {
return __awaiter(this, void 0, void 0, function* () {
const outFile = join(dist, filePath.replace(replNodeMdlExp, ''));
return new Promise((res) => {
if (!existsSync(outFile)) {
if (!existsSync(dirname(outFile))) {
mkdir('-p', dirname(outFile));
}
cp('-R', join(filePath), outFile);
res(true);
}
});
});
}
del(src, opts) {
return del(this.normalizeSrc(src), opts);
}
/**
* to root path.
*
* @param {string} pathstr
* @returns {string}
* @memberof NodeContext
*/
toRootPath(pathstr) {
let root = this.getRootPath();
return root ? toAbsolutePath(root, pathstr) : this.normalize(pathstr);
}
/**
* convert path to relative root path.
*
* @param {string} pathstr
* @returns {string}
* @memberof NodeActivityContext
*/
relativeRoot(pathstr) {
if (relChkExp.test(pathstr)) {
return pathstr;
}
let fullpath = this.toRootPath(pathstr);
return relative(this.getRootPath(), fullpath) || '.';
}
getRootPath() {
return this.ctx.baseURL;
}
toRootSrc(src) {
let root = this.getRootPath();
if (root) {
if (isString(src)) {
return this.prefixSrc(root, src);
}
else {
return src.map(s => this.prefixSrc(root, s));
}
}
return src;
}
relativePath(path1, path2) {
return relative(path1, path2);
}
prefixSrc(root, strSrc) {
let prefix = '';
if (notExp.test(strSrc)) {
prefix = '!';
strSrc = strSrc.substring(1, strSrc.length);
}
return prefix + toAbsolutePath(root, strSrc);
}
/**
* get package.
*
* @returns {*}
* @memberof NodeContext
*/
getPackage() {
if (!this._package) {
let filename = this.toRootPath(this.packageFile);
this._package = syncRequire(filename);
}
return this._package;
}
/**
* get package version.
*
* @returns {string}
* @memberof NodeContext
*/
getPackageVersion() {
let packageCfg = this.getPackage();
if (!packageCfg) {
return '';
}
return packageCfg.version || '';
}
/**
* get module version.
*
* @param {string} name
* @param {boolean} [dependencies=false]
* @returns {string}
* @memberof NodeContext
*/
getModuleVersion(name, dependencies = false) {
let packageCfg = this.getPackage();
if (!packageCfg) {
return '';
}
let version = '';
if (packageCfg.dependencies) {
version = packageCfg.dependencies[name];
}
if (!dependencies && !version && packageCfg.devDependencies) {
version = packageCfg.devDependencies[name];
}
return version || '';
}
static ρAnn() {
return { "name": "PlatformService", "params": { "constructor": ["ctx"], "hasArg": ["arg"], "getRootFolders": ["express"], "getCompilerOptions": ["tsconfig"], "getFileName": ["pathName"], "getFolders": ["pathstr", "express"], "getFiles": ["express", "options", "filter", "mapping"], "join": ["paths"], "normalize": ["url"], "normalizeSrc": ["src"], "copyFile": ["src", "dist", "options"], "existsFile": ["filename"], "copyDir": ["src", "dist", "options"], "copyTo": ["filePath", "dist"], "del": ["src", "opts"], "toRootPath": ["pathstr"], "relativeRoot": ["pathstr"], "toRootSrc": ["src"], "relativePath": ["path1", "path2"], "prefixSrc": ["root", "strSrc"], "getModuleVersion": ["name", "dependencies"] } };
}
};
PlatformService = __decorate([
Injectable(PlatformServiceToken),
__metadata("design:paramtypes", [NodeActivityContext])
], PlatformService);
/**
* activity for server side.
*
* @export
* @abstract
* @class NodeActivity
* @extends {Activity<T>}
* @template T
*/
class NodeActivity extends Activity {
static ρAnn() {
return { "name": "NodeActivity" };
}
}
/**
* Source activity.
*
* @export
* @class CleanActivity
* @extends {Activity}
*/
let CleanActivity = class CleanActivity extends NodeActivity {
execute(ctx) {
return __awaiter(this, void 0, void 0, function* () {
let clean = yield ctx.resolveExpression(this.clean);
if (clean) {
yield ctx.platform.del(ctx.platform.normalizeSrc(clean), { force: true, cwd: ctx.platform.getRootPath() });
}
});
}
static ρAnn() {
return { "name": "CleanActivity", "params": { "execute": ["ctx"] } };
}
};
__decorate([
Input(),
__metadata("design:type", Object)
], CleanActivity.prototype, "clean", void 0);
CleanActivity = __decorate([
Task('clean, [clean]')
], CleanActivity);
/**
* Serve activity.
*
* @export
* @class ServeActivity
* @extends {BuildActivity}
*/
let ServeActivity = class ServeActivity extends NodeActivity {
/**
* before run sequence.
*
* @protected
* @returns {Promise<void>}
* @memberof ServeActivity
*/
execute() {
return __awaiter(this, void 0, void 0, function* () {
});
}
static ρAnn() {
return { "name": "ServeActivity", "params": {} };
}
};
__decorate([
Input(),
__metadata("design:type", Number)
], ServeActivity.prototype, "port", void 0);
__decorate([
Input(),
__metadata("design:type", Object)
], ServeActivity.prototype, "dirs", void 0);
ServeActivity = __decorate([
Task('serve')
], ServeActivity);
const preWordExp = /^[a-zA-Z]/;
/**
* Shell Task
*
* @class ShellActivity
* @implements {ITask}
*/
let ShellActivity = class ShellActivity extends NodeActivity {
execute(ctx) {
return __awaiter(this, void 0, void 0, function* () {
let shell = yield ctx.resolveExpression(this.shell);
let options = yield ctx.resolveExpression(this.options);
let args = yield ctx.resolveExpression(this.args);
let argstrs = isArray(args) ? args : this.formatArgs(args);
let allowError = yield ctx.resolveExpression(this.allowError);
let shells = isArray(shell) ? shell : [shell];
if (this.parallel) {
yield Promise.all(shells.map(sh => this.execShell(sh, argstrs, options, allowError)));
}
else {
yield PromiseUtil.step(shells.map(sh => () => this.execShell(sh, argstrs, options, allowError)));
}
});
}
formatShell(shell, args) {
if (args.length) {
return shell + ' ' + args.join(' ');
}
return shell;
}
formatArgs(args) {
let strArgs = [];
lang.forIn(args, (val, k) => {
if (k === 'root' || !preWordExp.test(k)) {
return;
}
if (isArray(val)) {
strArgs.push(`--${k} ${val.join(',')}`);
}
else if (!isNullOrUndefined(val)) {
let arg = this.formatArg(val, k, args);
if (arg) {
strArgs.push(arg);
}
}
});
return strArgs;
}
formatArg(arg, key, args) {
if (isBoolean(arg) && arg) {
return `--${key}`;
}
if (!isNullOrUndefined(arg)) {
return `--${key} ${arg}`;
}
return '';
}
execShell(cmd, args, options, allowError) {
cmd = this.formatShell(cmd, args);
if (!cmd) {
return Promise.resolve();
}
return new Promise((resolve, reject) => {
let shell = exec(cmd, options, (err, stdout, stderr) => {
if (err) {
reject(err);
}
else {
resolve(stdout);
}
});
shell.stdout.on('data', data => {
this.checkStdout(data, resolve, reject);
});
shell.stderr.on('data', err => {
this.checkStderr(err, reject, allowError);
});
shell.on('exit', (code) => {
let msg = `exit child process with code：${code} `;
console.log(msg);
if (code > 0) {
reject(new Error(msg));
}
});
});
}
checkStderr(err, reject, allowError) {
console.error(err);
if (allowError === false) {
reject(err);
}
}
checkStdout(data, resolve, reject) {
console.log(data);
}
static ρAnn() {
return { "name": "ShellActivity", "params": { "execute": ["ctx"], "formatShell": ["shell", "args"], "formatArgs": ["args"], "formatArg": ["arg", "key", "args"], "execShell": ["cmd", "args", "options", "allowError"], "checkStderr": ["err", "reject", "allowError"], "checkStdout": ["data", "resolve", "reject"] } };
}
};
__decorate([
Input(),
__metadata("design:type", Object)
], ShellActivity.prototype, "shell", void 0);
__decorate([
Input(),
__metadata("design:type", Object)
], ShellActivity.prototype, "args", void 0);
__decorate([
Input(),
__metadata("design:type", Object)
], ShellActivity.prototype, "options", void 0);
__decorate([
Input(),
__metadata("design:type", Object)
], ShellActivity.prototype, "allowError", void 0);
__decorate([
Input(),
__metadata("design:type", Boolean)
], ShellActivity.prototype, "parallel", void 0);
ShellActivity = __decorate([
Task('shell')
], ShellActivity);
let UnitTestActivity = class UnitTestActivity extends NodeActivity {
execute(ctx) {
return __awaiter(this, void 0, void 0, function* () {
let test = yield ctx.resolveExpression(this.test);
let options = yield ctx.resolveExpression(this.options);
if (test) {
yield runTest(test, Object.assign({ baseURL: ctx.platform.getRootPath() }, options), ConsoleReporter);
}
});
}
static ρAnn() {
return { "name": "UnitTestActivity", "params": { "execute": ["ctx"] } };
}
};
__decorate([
Input(),
__metadata("design:type", Object)
], UnitTestActivity.prototype, "test", void 0);
__decorate([
Input('testOptions'),
__metadata("design:type", Object)
], UnitTestActivity.prototype, "options", void 0);
UnitTestActivity = __decorate([
Task('test, [test]')
], UnitTestActivity);
const chokidar = require('chokidar');
/**
* watch activity.
*
* @export
* @class WatchActivity
* @extends {BuildHandleActivity}
*/
let WatchActivity = class WatchActivity extends NodeActivity {
execute(ctx) {
return __awaiter(this, void 0, void 0, function* () {
let watchSrc = this.watch;
let options = this.options;
let watcher = chokidar.watch(ctx.platform.normalizeSrc(watchSrc), Object.assign({ ignored: /[\/\\]\./, ignoreInitial: true, cwd: ctx.platform.getRootPath() }, options));
let defer = PromiseUtil.defer();
fromEventPattern(handler => {
watcher.on('add', paths => handler(paths));
watcher.on('change', paths => handler(paths));
watcher.on('unlink', paths => handler(paths));
watcher.on('unlinkDir', paths => handler(paths));
}, handler => {
watcher.close();
})
.pipe(bufferTime(300), filter(c => c.length > 0))
.subscribe(chg => {
ctx.getExector().runActivity(this.body);
});
defer.promise;
});
}
static ρAnn() {
return { "name": "WatchActivity", "params": { "execute": ["ctx"] } };
}
};
__decorate([
Input(),
__metadata("design:type", Object)
], WatchActivity.prototype, "watch", void 0);
__decorate([
Input('watchOptions'),
__metadata("design:type", Object)
], WatchActivity.prototype, "options", void 0);
__decorate([
Input({ bindingType: 'dynamic' }),
__metadata("design:type", Object)
], WatchActivity.prototype, "body", void 0);
WatchActivity = __decorate([
Task('watch')
], WatchActivity);
var tasks = /*#__PURE__*/Object.freeze({
__proto__: null,
get CleanActivity () { return CleanActivity; },
get ServeActivity () { return ServeActivity; },
get ShellActivity () { return ShellActivity; },
get UnitTestActivity () { return UnitTestActivity; },
get WatchActivity () { return WatchActivity; }
});
/**
* rollup activity.
*
* @export
* @class RollupActivity
* @extends {NodeActivity<void>}
*/
let RollupActivity = class RollupActivity extends NodeActivity {
execute(ctx) {
return __awaiter(this, void 0, void 0, function* () {
let opts = yield ctx.resolveExpression(this.options);
opts = opts || { input: '' };
yield Promise.all(this.getInputProps()
.map((n) => __awaiter(this, void 0, void 0, function* () {
let val = yield ctx.resolveExpression(this[n]);
this.setOptions(ctx, opts, n, val);
})));
yield Promise.all((isArray(opts.output) ? opts.output : [opts.output]).map((output) => __awaiter(this, void 0, void 0, function* () {
if (this.sourcemap) {
let sourceMap = yield ctx.resolveExpression(this.sourcemap);
if (sourceMap) {
output.sourcemap = isString(sourceMap) ? true : sourceMap;
}
}
if (this.globals) {
let globals = yield ctx.resolveExpression(this.globals);
output.globals = globals;
}
else {
output.globals = {};
}
if (isArray(opts.external) && opts.external.length) {
opts.external = this.vailfExternal(opts.external);
opts.external.forEach(k => {
if (output.globals[k]) {
output.globals[k] = k;
}
});
}
if (output.file) {
output.file = ctx.platform.toRootPath(output.file);
}
if (output.dir) {
output.dir = ctx.platform.toRootPath(output.dir);
}
if (!output.name && output.file) {
output.name = ctx.platform.getFileName(output.file);
}
yield this.resolvePlugins(ctx, opts);
if (opts.plugins) {
opts.plugins = opts.plugins.filter(p => p);
}
let bundle = yield rollup(opts);
yield bundle.write(output);
}))).catch(err => {
console.error(err);
throw err;
});
});
}
getInputProps() {
return ['input', 'output', 'plugins', 'external', 'cache', 'watch'];
}
setOptions(ctx, opts, key, val) {
if (key === 'input') {
val = ctx.platform.toRootSrc(val);
}
if (isArray(val) && val.length) {
val = val.filter(f => !isNullOrUndefined(f));
if (val.length) {
opts[key] = val;
}
}
else if (val) {
opts[key] = val;
}
}
vailfExternal(external) {
return external || [];
}
resolvePlugins(ctx, opts) {
return __awaiter(this, void 0, void 0, function* () {
});
}
static ρAnn() {
return { "name": "RollupActivity", "params": { "execute": ["ctx"], "setOptions": ["ctx", "opts", "key", "val"], "vailfExternal": ["external"], "resolvePlugins": ["ctx", "opts"] } };
}
};
__decorate([
Input(),
__metadata("design:type", Object)
], RollupActivity.prototype, "input", void 0);
__decorate([
Input(),
__metadata("design:type", Object)
], RollupActivity.prototype, "output", void 0);
__decorate([
Input(),
__metadata("design:type", Object)
], RollupActivity.prototype, "plugins", void 0);
__decorate([
Input(),
__metadata("design:type", Object)
], RollupActivity.prototype, "external", void 0);
__decorate([
Input(),
__metadata("design:type", Object)
], RollupActivity.prototype, "globals", void 0);
__decorate([
Input(),
__metadata("design:type", Object)
], RollupActivity.prototype, "sourcemap", void 0);
__decorate([
Input(),
__metadata("design:type", Object)
], RollupActivity.prototype, "cache", void 0);
__decorate([
Input(),
__metadata("design:type", Object)
], RollupActivity.prototype, "options", void 0);
__decorate([
Input(),
__metadata("design:type", Object)
], RollupActivity.prototype, "watch", void 0);
RollupActivity = __decorate([
Task('rollup')
], RollupActivity);
const tsdexp = /.d.ts$/;
const mapexp = /.map$/;
const tsFileExp = /.ts$/;
const jsFileExp = /.js$/;
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), resolve$1(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);
const TSLIB_ID = '\0tslib';
let RollupTsActivity = class RollupTsActivity extends RollupActivity {
execute(ctx) {
const _super = Object.create(null, {
execute: { get: () => super.execute }
});
return __awaiter(this, void 0, void 0, function* () {
this.exeCache = {};
yield _super.execute.call(this, ctx);
delete this.exeCache;
});
}
getInputProps() {
return [...super.getInputProps(), 'beforeCompile', 'afterCompile'];
}
vailfExternal(external) {
if (this.includeLib && this.includeLib.length) {
return (external || []).filter(ex => this.includeLib.indexOf(ex) < 0);
}
return super.vailfExternal(external);
}
setOptions(ctx, opts, key, val) {
if (key === 'beforeCompile') {
this.exeCache.beforeCompile = val;
}
else if (key === 'afterCompile') {
this.exeCache.afterCompile = val;
}
else {
super.setOptions(ctx, opts, key, val);
}
}
resolvePlugins(ctx, opts) {
return __awaiter(this, void 0, void 0, function* () {
let plugins = [];
let { beforeCompile, afterCompile } = this.exeCache;
if (beforeCompile && beforeCompile.length) {
plugins.push(...beforeCompile);
}
if (this.tscompile) {
let compile = yield ctx.resolveExpression(this.tscompile);
plugins.push(compile);
}
else {
plugins.push(yield this.getDefaultTsCompiler(ctx));
}
if (opts.plugins && opts.plugins.length) {
plugins.push(...opts.plugins);
}
if (afterCompile && afterCompile.length) {
plugins.push(...afterCompile);
}
if (this.uglify) {
let ugfy = yield ctx.resolveExpression(this.uglify);
const uglify = syncRequire('rollup-plugin-uglify');
if (isBoolean(ugfy)) {
ugfy && plugins.push(uglify());
}
else {
plugins.push(ugfy);
}
}
opts.plugins = plugins;
});
}
getDefaultTsCompiler(ctx) {
return __awaiter(this, void 0, void 0, function* () {
const tslib = syncRequire('tslib');
let include = yield ctx.resolveExpression(this.include);
let exclude = yield ctx.resolveExpression(this.exclude);
let annotation = yield ctx.resolveExpression(this.annotation);
const filter = createFilter(include, exclude);
let compile = ctx.injector.get(TsComplie);
let projectDirectory = ctx.platform.getRootPath();
let settings = yield ctx.resolveExpression(this.compileOptions);
let tsconfig = yield ctx.resolveExpression(this.tsconfig);
tsconfig = ctx.platform.toRootPath(tsconfig);
let parsed = compile.parseTsconfig(projectDirectory, tsconfig, settings);
const allImportedFiles = new Set();
return {
name: 'typescript',
resolveId(importee, importer) {
if (importee === 'tslib') {
return TSLIB_ID;
}
if (!importer) {
return null;
}
importer = ctx.platform.normalize(importer);
if (!allImportedFiles.has(importer)) {
return;
}
const result = nodeModuleNameResolver(importee, importer, parsed.options, sys);
if (result.resolvedModule && result.resolvedModule.resolvedFileName) {
if (tsdexp.test(result.resolvedModule.resolvedFileName || '')) {
return null;
}
return result.resolvedModule.resolvedFileName;
}
return null;
},
load(id) {
if (id === TSLIB_ID) {
return tslib;
}
},
transform(code, id) {
if (!filter(id)) {
return undefined;
}
allImportedFiles.add(id.split('\\').join('/'));
return compile.transpileModule(parsed.options, id, code, annotation);
}
};
});
}
static ρAnn() {
return { "name": "RollupTsActivity", "params": { "execute": ["ctx"], "vailfExternal": ["external"], "setOptions": ["ctx", "opts", "key", "val"], "resolvePlugins": ["ctx", "opts"], "getDefaultTsCompiler": ["ctx"] } };
}
};
__decorate([
Input('beforeCompilePlugins'),
__metadata("design:type", Object)
], RollupTsActivity.prototype, "beforeCompile", void 0);
__decorate([
Input(),
__metadata("design:type", Object)
], RollupTsActivity.prototype, "tscompile", void 0);
__decorate([
Input('afterCompilePlugins'),
__metadata("design:type", Object)
], RollupTsActivity.prototype, "afterCompile", void 0);
__decorate([
Input(),
__metadata("design:type", Array)
], RollupTsActivity.prototype, "includeLib", void 0);
__decorate([
Input(),
__metadata("design:type", Object)
], RollupTsActivity.prototype, "annotation", void 0);
__decorate([
Input('include', ['*.ts+(|x)', '**/*.ts+(|x)']),
__metadata("design:type", Object)
], RollupTsActivity.prototype, "include", void 0);
__decorate([
Input('exclude', ['*.d.ts', '**/*.d.ts']),
__metadata("design:type", Object)
], RollupTsActivity.prototype, "exclude", void 0);
__decorate([
Input(),
__metadata("design:type", Object)
], RollupTsActivity.prototype, "dts", void 0);
__decorate([
Input('tsconfig', './tsconfig.json'),
__metadata("design:type", Object)
], RollupTsActivity.prototype, "tsconfig", void 0);
__decorate([
Input(),
__metadata("design:type", Object)
], RollupTsActivity.prototype, "compileOptions", void 0);
__decorate([
Input(),
__metadata("design:type", Object)
], RollupTsActivity.prototype, "uglify", void 0);
RollupTsActivity = __decorate([
Task({
selector: 'rts'
})
], RollupTsActivity);
var rollups = /*#__PURE__*/Object.freeze({
__proto__: null,
get RollupActivity () { return RollupActivity; },
get RollupTsActivity () { return RollupTsActivity; }
});
/**
* transform activity.
*
* @export
* @abstract
* @class TransfrmActivity
* @extends {NodeActivity<ITransform>}
*/
class TransformActivity extends NodeActivity {
/**
* execute stream pipe.
*
* @protected
* @param {NodeActivityContext} ctx
* @param {ITransform} stream stream pipe from
* @param {GActivityType<ITransform>} transform steam pipe to.
* @param {boolean} [waitend=false] wait pipe end or not.
* @returns {Promise<ITransform>}
* @memberof TransformActivity
*/
pipeStream(ctx, stream, transform, waitend = false) {
return __awaiter(this, void 0, void 0, function* () {
let transPipe;
if (isTransform(transform)) {
transPipe = transform;
}
else {
transPipe = yield ctx.resolveExpression(transform);
}
let next = stream.pipe(transPipe);
next.once('error', err => {
console.error(err);
if (isDefined(process)) {
process.exit(1);
}
throw err;
});
if (waitend) {
let defer = PromiseUtil.defer();
next.once('end', defer.resolve);
yield defer.promise;
}
return next;
});
}
static ρAnn() {
return { "name": "TransformActivity" };
}
}
let AnnotationActivity = class AnnotationActivity extends TransformActivity {
execute(ctx) {
return __awaiter(this, void 0, void 0, function* () {
let enable = yield ctx.resolveExpression(this.annotation);
if (enable) {
return yield this.pipeStream(ctx, ctx.getData(), this.framework);
}
});
}
static ρAnn() {
return { "name": "AnnotationActivity", "params": { "execute": ["ctx"] } };
}
};
__decorate([
Input('annotationFramework', classAnnotations),
__metadata("design:type", Object)
], AnnotationActivity.prototype, "framework", void 0);
__decorate([
Input(),
__metadata("design:type", Object)
], AnnotationActivity.prototype, "annotation", void 0);
AnnotationActivity = __decorate([
Task('annotation')
], AnnotationActivity);
const uglify = require('gulp-uglify-es').default;
let UglifyActivity = class UglifyActivity extends TransformActivity {
execute(ctx) {
return __awaiter(this, void 0, void 0, function* () {
let options = yield ctx.resolveExpression(this.options);
return ctx.getData().pipe(options ? uglify(options) : uglify());
});
}
static ρAnn() {
return { "name": "UglifyActivity", "params": { "execute": ["ctx"] } };
}
};
__decorate([
Input('uglifyOptions'),
__metadata("design:type", Object)
], UglifyActivity.prototype, "options", void 0);
UglifyActivity = __decorate([
Task('uglify, [uglify]')
], UglifyActivity);
const jeditor = require('gulp-json-editor');
const inplace = require('json-in-place');
/**
* edit json, will format new json string.
*
* @export
* @class JsonEditActivity
* @extends {TransformActivity}
*/
let JsonEditActivity = class JsonEditActivity extends TransformActivity {
execute(ctx) {
return __awaiter(this, void 0, void 0, function* () {
if (!this.json) {
return;
}
if (isFunction(this.json)) {
let jsonFunc = this.json;
return jeditor((json) => jsonFunc(json));
}
else {
return jeditor(this.json);
}
});
}
static ρAnn() {
return { "name": "JsonEditActivity", "params": { "execute": ["ctx"] } };
}
};
__decorate([
Input(),
__metadata("design:type", Object)
], JsonEditActivity.prototype, "json", void 0);
JsonEditActivity = __decorate([
Task('jsonEdit')
], JsonEditActivity);
/**
* replace json value of key. no format.
*
* @export
* @class JsonReplaceActivity
* @extends {TransformActivity}
*/
let JsonReplaceActivity = class JsonReplaceActivity extends TransformActivity {
execute(ctx) {
return __awaiter(this, void 0, void 0, function* () {
let fields = this.fields;
if (!isFunction(fields)) {
return;
}
return obj(function (file, encoding, callback) {
if (file.isNull()) {
return callback(null, file);
}
if (file.isStream()) {
return callback('doesn\'t support Streams');
}
let contents = file.contents.toString('utf8');
let json = JSON.parse(contents);
let replaced = inplace(contents);
let changs = fields(json);
if (changs instanceof Map) {
changs.forEach((val, key) => {
replaced.set(key, val);
});
}
else {
lang.forIn(fields(json), (val, key) => {
replaced.set(key, val);
});
}
contents = replaced.toString();
file.contents = Buffer.from(contents);
callback(null, file);
});
});
}
static ρAnn() {
return { "name": "JsonReplaceActivity", "params": { "execute": ["ctx"] } };
}
};
__decorate([
Input(),
__metadata("design:type", Function)
], JsonReplaceActivity.prototype, "fields", void 0);
JsonReplaceActivity = __decorate([
Task('jsonReplace')
], JsonReplaceActivity);
const sourcemaps = require('gulp-sourcemaps');
let AssetActivity = class AssetActivity {
static ρAnn() {
return { "name": "AssetActivity", "params": {} };
}
};
__decorate([
Input(),
__metadata("design:type", Object)
], AssetActivity.prototype, "src", void 0);
__decorate([
Input(),
__metadata("design:type", Object)
], AssetActivity.prototype, "dist", void 0);
__decorate([
Input(),
__metadata("design:type", Object)
], AssetActivity.prototype, "sourcemap", void 0);
__decorate([
Input('sourceMapFramework'),
__metadata("design:type", Object)
], AssetActivity.prototype, "framework", void 0);
__decorate([
Input('pipes'),
__metadata("design:type", Array)
], AssetActivity.prototype, "pipes", void 0);
AssetActivity = __decorate([
Task({
selector: 'asset',
template: [
{
activity: 'src',
src: 'binding: src'
},
{
activity: Activities.if,
condition: 'binding: sourcemap',
body: {
name: 'sourcemap-init',
activity: Activities.execute,
action: (ctx, bind) => {
let framework = bind.getScope().framework || sourcemaps;
return ctx.getData().pipe(framework.init());
}
}
},
{
activity: 'pipes',
pipes: 'binding: pipes'
},
{
activity: Activities.if,
condition: 'binding: sourcemap',
body: {
name: 'sourcemap-write',
activity: Activities.execute,
action: (ctx, bind) => {
let scope = bind.getScope();
let framework = scope.framework || sourcemaps;
return ctx.getData().pipe(framework.write(isString(scope.sourcemap) ? scope.sourcemap : './sourcemaps'));
}
}
},
{
activity: 'dist',
dist: 'binding: dist',
}
]
})
], AssetActivity);
/**
* source stream to dist activity.
*
* @export
* @class DestActivity
* @extends {TransformActivity}
*/
let DestActivity = class DestActivity extends TransformActivity {
execute(ctx) {
return __awaiter(this, void 0, void 0, function* () {
let dist = yield ctx.resolveExpression(this.dist);
if (dist) {
let options = yield ctx.resolveExpression(this.options);
dist = ctx.platform.toRootPath(dist);
yield this.pipeStream(ctx, ctx.getData(), options ? dest(dist, options) : dest(dist), this.end !== false);
}
});
}
static ρAnn() {
return { "name": "DestActivity", "params": { "execute": ["ctx"] } };
}
};
__decorate([
Input(),
__metadata("design:type", Boolean)
], DestActivity.prototype, "end", void 0);
__decorate([
Input(),
__metadata("design:type", Object)
], DestActivity.prototype, "dist", void 0);
__decorate([
Input('destOptions'),
__metadata("design:type", Object)
], DestActivity.prototype, "options", void 0);
DestActivity = __decorate([
Task('dist, [dist]')
], DestActivity);
/**
* Source activity.
*
* @export
* @class SourceActivity
* @extends {TransformActivity}
*/
let SourceActivity = class SourceActivity extends TransformActivity {
execute(ctx) {
return __awaiter(this, void 0, void 0, function* () {
let strSrc = yield ctx.resolveExpression(this.src);
if (strSrc) {
let options = yield ctx.resolveExpression(this.options);
return src(ctx.platform.normalizeSrc(strSrc), Object.assign({ cwd: ctx.platform.getRootPath() }, options || {}));
}
});
}
static ρAnn() {
return { "name": "SourceActivity", "params": { "execute": ["ctx"] } };
}
};
__decorate([
Input(),
__metadata("design:type", Object)
], SourceActivity.prototype, "src", void 0);
__decorate([
Input('srcOptions'),
__metadata("design:type", Object)
], SourceActivity.prototype, "options", void 0);
SourceActivity = __decorate([
Task('src, [src]')
], SourceActivity);
let StreamActivity = class StreamActivity extends TransformActivity {
execute(ctx) {
return __awaiter(this, void 0, void 0, function* () {
let pipes = yield ctx.resolveExpression(this.pipes);
if (isArray(pipes)) {
pipes = pipes.filter(p => p);
}
if (pipes && pipes.length) {
return yield this.pipeStreams(ctx, ctx.getData(), ...pipes);
}
});
}
/**
* stream pipe transform.
*
* @protected
* @param {NodeActivityContext} ctx
* @param {ITransform} stream
* @param {...Expression<ITransform>[]} pipes
* @returns {Promise<ITransform>}
* @memberof StreamActivity
*/
pipeStreams(ctx, stream, ...pipes) {
return __awaiter(this, void 0, void 0, function* () {
if (pipes.length < 1) {
return stream;
}
if (pipes.length === 1) {
return yield this.pipeStream(ctx, stream, pipes[0]);
}
let pstream = Promise.resolve(stream);
pipes.forEach(transform => {
if (transform) {
pstream = pstream
.then(stm => {
return this.pipeStream(ctx, stm, transform);
});
}
});
return yield pstream;
});
}
static ρAnn() {
return { "name": "StreamActivity", "params": { "execute": ["ctx"], "pipeStreams": ["ctx", "stream", "pipes"] } };
}
};
__decorate([
Input('pipes'),
__metadata("design:type", Array)
], StreamActivity.prototype, "pipes", void 0);
StreamActivity = __decorate([
Task('pipes, [pipes]')
], StreamActivity);
const sourcemaps$1 = 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$1;
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 c