type-task
v0.5.5
Published
type-task is task manager via AOP, IOC.
Downloads
16
Maintainers
Readme
packaged type-task
This repo is for distribution on npm
. The source for this module is in the
main repo.
Please file issues and pull requests against that repo.
type-task
is task manager via AOP, IOC.
Install
- install modules:
npm install -g type-task
- install cil:
npm install type-task
use command: type-task [task names] [--param param]
taskname: decorator class with @Task('taskname')
or @TaskModule({name:'taskname'})
.
You can import
modules:
Doc
Define Task
- Single task
@Task('test')
class SimpleTask extends AbstractTask implements ITask {
constructor(name: string) {
super(name);
}
run(): Promise<any> {
// console.log('before simple task:', this.name);
return Promise.resolve('simple task')
.then(val => {
console.log('return simple task:', val);
return val;
});
}
}
- Component task
@Task
class DelComponentTask extends TaskElement {
execute(data?: any): Promise<any> {
return del(['lib/**']);
}
}
- Task module
@TaskModule({
providers: <IPipeElementProvider>{
name: 'tscomplie',
src: 'src/**/*.ts',
dest: 'lib',
pipes: [
(ctx) => cache('typescript'),
(ctx) => classAnnotations(),
sourcemaps.init,
(ctx) => tsProject()
]
},
task: PipeElement
})
class TsCompile extends TaskElement {
}
Run task
see interface
1.
let container = new TaskContainer(__dirname, moudles)
2.
TaskContainer.create(__dirname, moudles)
.bootstrap(<IConfigure>{
...
task:...
});
3.
TaskContainer.create(__dirname, moudles)
.bootstrap(TestTask);
4.
TaskContainer.create(__dirname)
.bootstrap([TestTask, TsCompile, <IConfigure>{
...
task: ...
}]);
Simples
more simples see
import { Task, ITask, taskSymbols, TaskContainer, AbstractTask, TaskElement, PipeElement, ITaskComponent, IConfigure, PipeComponent, IPipeElementProvider, TaskModule, ITransform, Src, PipeExpress, RunWay, TransformExpress, TransformType } from 'type-task';
import * as mocha from 'gulp-mocha';
const del = require('del');
const cache = require('gulp-cached');
const ts = require('gulp-typescript');
const sourcemaps = require('gulp-sourcemaps');
const uglify = require('gulp-uglify');
import { classAnnotations } from 'typescript-class-annotations';
import { isFunction, isBoolean, ObjectMap } from 'tsioc';
@TaskModule({
providers: <IPipeElementProvider>{
pipes: [
() => cache('typescript'),
sourcemaps.init,
() => classAnnotations(),
(ctx, config) => {
let target = config.moduleTarget as TsCompile;
if (target.tsconfig) {
return ts(target.tsconfig);
} else {
let tsProject = ts.createProject(ctx.toRootPath(target.tsconfigFile || './tsconfig.json'));
return tsProject();
}
}
],
destPipes: {
js: [
(ctx, config, transform) => {
let trans: ITransform = transform.js;
trans.changeAsOrigin = true;
return trans;
},
(ctx, config) => {
let target = config.moduleTarget as TsCompile;
if (target.uglify) {
return isBoolean(target.uglify) ? uglify() : uglify(target.uglify);
}
return null;
},
(ctx) => sourcemaps.write('./sourcemaps')
],
dts: [
(ctx, config, transform) => {
let tans: ITransform = transform.dts;
tans.changeAsOrigin = true;
return tans;
}
]
}
},
task: PipeElement
})
export class TsCompile extends TaskElement {
constructor(name: string, runWay?: RunWay, public src?: Src, public dest?: Src,
private tsPipes?: TransformExpress, private jsPipes?: TransformExpress,
public tsconfigFile?: string, public tsconfig?: ObjectMap<any>, public uglify?: boolean | ObjectMap<any>) {
super(name, runWay);
}
onInit() {
let providers = this.config.providers as IPipeElementProvider;
console.log('src:', this.src, 'dest:', this.dest, 'providers:', providers);
if (this.src) {
providers.src = this.src;
}
if (this.dest) {
providers.dest = this.dest;
}
if (this.tsPipes) {
let pipes: TransformType[] = isFunction(providers.pipes) ? providers.pipes(this.context, this.config) : providers.pipes;
let tsPipes: TransformType[] = isFunction(this.tsPipes) ? this.tsPipes(this.context, this.config) : this.tsPipes;
pipes.splice(1, 0, ...tsPipes);
providers.pipes = pipes;
}
if (this.jsPipes) {
let destPipes: any = isFunction(providers.destPipes) ? providers.destPipes(this.context, this.config) : providers.destPipes;
destPipes.js = isFunction(destPipes.js) ? destPipes.js(this.context, this.config) : destPipes.js;
let jsPipes: TransformType[] = isFunction(this.jsPipes) ? this.jsPipes(this.context, this.config) : this.jsPipes;
destPipes.js.splice(1, 0, ...jsPipes);
providers.destPipes = destPipes;
}
this.config.providers = providers;
}
}
@TaskModule({
providers: {
name: 'test',
src: 'test/**/*.spec.ts',
awaitPiped: true,
pipes: [() => mocha()]
},
task: PipeElement
})
class TestTask extends TaskElement {
execute(data?: any): Promise<any> {
return del(['lib/**', 'bin/**']);
}
}
TaskContainer.create(__dirname)
.bootstrap([
TestTask,
{
providers: {
name: 'tscompLIB',
src: ['src/**/*.ts', '!src/cli/**'],
dest: 'lib',
uglify: true
},
task: TsCompile
},
{
providers: {
name: 'tscompCLI',
src: 'src/cli/*.ts',
dest: 'bin',
uglify: true
},
task: TsCompile
}]);
Documentation github
Documentation is available on the type-task docs site.
License
MIT © Houjun