kylefang/DefinitelyTyped
1
0
Fork 0
mirror of https://github.com/zhigang1992/DefinitelyTyped.git synced 2026-05-30 18:43:21 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #16494 from TeamworkGuy2/orchestrator

Browse Source 
[orchestrator & gulp] Improved types based on orchestrator 0.3.8 source code
This commit is contained in:
Arthur Ozga
2017-05-18 15:04:27 -07:00
committed by GitHub
parent ea05927bbf 98f0e4b428
commit 92c9457bd1
4 changed files with 175 additions and 103 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
types/gulp/gulp-tests.ts
View File

@@ -1,32 +1,31 @@
import gulp = require("gulp");
import browserSync = require("browser-sync");
var typescript: gulp.GulpPlugin = null; // this would be the TypeScript compiler
var jasmine: gulp.GulpPlugin = null; // this would be the jasmine test runner
gulp.task('compile', function()
{
gulp.task('compile', function() {
gulp.src("**/*.ts")
.pipe(typescript())
.pipe(gulp.dest('out'))
});
gulp.task('compile2', function(callback: (err?: any) => void)
{
gulp.task('compile2', function(callback: (err?: any) => void) {
gulp.src("**/*.ts")
.pipe(typescript())
.pipe(gulp.dest('out'))
.on('end', callback);
});
gulp.task('test', ['compile', 'compile2'], function()
{
gulp.task('test', ['compile', 'compile2'], function() {
gulp.src("out/test/**/*.js")
.pipe(jasmine());
});
gulp.task('default', ['compile', 'test']);
gulp.task('another', ['with1', 'with2'])
.task('some', ['other1', 'other2'], function(cb) { cb(null); })
.task('last', function() { });
var opts = {};
@@ -61,8 +60,7 @@ var watcher = gulp.watch('*.html', event => {
});
gulp.task('serve', ['compile'], () => {
var browser = browserSync.create();
gulp.watch(['*.html', '*.ts'], ['compile', browser.reload]);
gulp.watch(['*.html', '*.ts'], ['compile', () => { return "data"; }]);
});
gulp.start('test', 'compile');

15
types/gulp/index.d.ts vendored
View File

@@ -14,6 +14,7 @@ declare type Strings = string|string[];
declare namespace gulp {
interface Gulp extends Orchestrator {
task(name: string): never;
/**
* Define a task
* @param name The name of the task.
@@ -24,7 +25,19 @@ declare namespace gulp {
* <li>Return a stream or a promise</li>
* </ul>
*/
task: Orchestrator.AddMethod;
task(name: string, fn?: Orchestrator.TaskFunc): Gulp;
/**
* Define a task
* @param name The name of the task.
* @param deps An array of task names to be executed and completed before your task will run.
* @param fn The function that performs the task's operations. For asynchronous tasks, you need to provide a hint when the task is complete:
* <ul>
* <li>Take in a callback</li>
* <li>Return a stream or a promise</li>
* </ul>
*/
task(name: string, deps?: string[], fn?: Orchestrator.TaskFunc): Gulp;
/**
* Takes a number of task names or functions and returns a function of the composed tasks or functions
* When the returned function is executed, the tasks or functions will be executed in series,

183
types/orchestrator/index.d.ts vendored
View File

@@ -1,107 +1,143 @@
// Type definitions for Orchestrator
// Type definitions for Orchestrator 0.3
// Project: https://github.com/orchestrator/orchestrator
// Definitions by: Qubo <https://github.com/tkQubo>
// Definitions by: Qubo <https://github.com/tkQubo>, TeamworkGuy2 <https://github.com/TeamworkGuy2>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
/// <reference types="node" />
import * as events from "events";
import * as stream from "stream";
import * as Q from "q";
declare type Strings = string|string[];
/** A module for sequencing and executing tasks and dependencies in maximum concurrency
*/
declare class Orchestrator extends events.EventEmitter {
doneCallback?: (error?: any) => any;
isRunning: boolean;
seq: any[];
tasks: { [name: string]: Orchestrator.Task };
declare class Orchestrator {
add: Orchestrator.AddMethod;
/**
* Have you defined a task with this name?
reset(): Orchestrator;
/** Define a task
* @param name The name of the task.
* @param fn The function that performs the task's operations. For asynchronous tasks, you need to provide a hint when the task is complete:
* - Take in a callback
* - Return a stream or a promise
*/
add(name: string, fn?: Orchestrator.TaskFunc): Orchestrator;
/** Define a task
* @param name The name of the task.
* @param deps An array of task names to be executed and completed before your task will run.
* @param fn The function that performs the task's operations. For asynchronous tasks, you need to provide a hint when the task is complete:
* - Take in a callback
* - Return a stream or a promise
*/
add(name: string, deps?: string[], fn?: Orchestrator.TaskFunc): Orchestrator;
task(name: string): Orchestrator.Task;
task(name: string, fn: Orchestrator.TaskFunc): void;
task(name: string, dep: string[], fn: Orchestrator.TaskFunc): void;
/** Have you defined a task with this name?
* @param name The task name to query
*/
hasTask(name: string): boolean;
start: Orchestrator.StartMethod;
stop(): void;
/**
* Listen to orchestrator internals
start: Orchestrator.StartMethod;
stop(err?: any, successfulFinish?: boolean): void;
sequence: Orchestrator.Sequencify;
allDone(): boolean;
/** Listen to orchestrator internals
* @param event Event name to listen to:
* <ul>
* <li>start: from start() method, shows you the task sequence
* <li>stop: from stop() method, the queue finished successfully
* <li>err: from stop() method, the queue was aborted due to a task error
* <li>task_start: from _runTask() method, task was started
* <li>task_stop: from _runTask() method, task completed successfully
* <li>task_err: from _runTask() method, task errored
* <li>task_not_found: from start() method, you're trying to start a task that doesn't exist
* <li>task_recursion: from start() method, there are recursive dependencies in your task list
* </ul>
* - start: from start() method, shows you the task sequence
* - stop: from stop() method, the queue finished successfully
* - err: from stop() method, the queue was aborted due to a task error
* - task_start: from _runTask() method, task was started
* - task_stop: from _runTask() method, task completed successfully
* - task_err: from _runTask() method, task errored
* - task_not_found: from start() method, you're trying to start a task that doesn't exist
* - task_recursion: from start() method, there are recursive dependencies in your task list
* @param cb Passes single argument: e: event details
*/
on(event: string, cb: (e: Orchestrator.OnCallbackEvent) => any): Orchestrator;
on(event: Orchestrator.EventNames, cb: (e: Orchestrator.OnCallbackEvent) => any): this;
/**
* Listen to all orchestrator events from one callback
/** Listen to all orchestrator events from one callback
* @param cb Passes single argument: e: event details
*/
onAll(cb: (e: Orchestrator.OnAllCallbackEvent) => any): void;
// probably supposed to be private methods, but still available on Orchestrator prototype
_resetTask(task: Orchestrator.Task): void;
_resetAllTasks(): void;
_resetSpecificTasks(names: string[]): void;
_runStep(): void;
_readyToRunTask(task: Orchestrator.Task): boolean;
_stopTask(task: Orchestrator.Task, meta: Orchestrator.Meta): void;
_emitTaskDone(task: Orchestrator.Task, message: string, err?: any): void;
_runTask(task: Orchestrator.Task): void;
}
declare namespace Orchestrator {
interface AddMethodCallback {
/**
* Accept a callback
* @param callback
*/
(callback?: Function): any;
/**
* Return a promise
*/
(): Q.Promise<any>;
/**
* Return a stream: (task is marked complete when stream ends)
*/
(): any; //TODO: stream type should be here e.g. map-stream
}
type Strings = string | string[];
/**
* Define a task
/** The method export generated by orchestrator/lib/runTask.js */
type RunTask = (task: Orchestrator.TaskFunc, done: (err: any, meta: Orchestrator.Meta) => void) => void;
/** The module export of the sequencify package: https://www.npmjs.com/package/sequencify */
type Sequencify = (tasks: Array<{ dep: string[]; }>, names: string[]) => {
sequence: string[];
missingTasks: string[];
recursiveDependencies: string[];
};
/** A task, can either call a callback to indicate task completion or return a promise or a stream: (task is marked complete when promise.then() resolves/fails or stream ends)
*/
type TaskFunc = (callback: (err?: any) => void) => Q.Promise<any> | stream.Stream | any;
interface AddMethod {
/**
* Define a task
/** Define a task
* @param name The name of the task.
* @param fn The function that performs the task's operations. For asynchronous tasks, you need to provide a hint when the task is complete:
* - Take in a callback
* - Return a stream or a promise
*/
(name: string, fn?: TaskFunc): Orchestrator;
/** Define a task
* @param name The name of the task.
* @param deps An array of task names to be executed and completed before your task will run.
* @param fn The function that performs the task's operations. For asynchronous tasks, you need to provide a hint when the task is complete:
* <ul>
* <li>Take in a callback</li>
* <li>Return a stream or a promise</li>
* </ul>
* - Take in a callback
* - Return a stream or a promise
*/
(name: string, deps?: string[], fn?: AddMethodCallback|Function): Orchestrator;
/**
* Define a task
* @param name The name of the task.
* @param fn The function that performs the task's operations. For asynchronous tasks, you need to provide a hint when the task is complete:
* <ul>
* <li>Take in a callback</li>
* <li>Return a stream or a promise</li>
* </ul>
*/
(name: string, fn?: AddMethodCallback|Function): Orchestrator;
(name: string, deps?: string[], fn?: TaskFunc): Orchestrator;
}
/**
* Start running the tasks
/** Start running the tasks
*/
interface StartMethod {
/**
* Start running the tasks
/** Start running the tasks
* @param tasks Tasks to be executed. You may pass any number of tasks as individual arguments.
* @param cb Callback to call after run completed.
*/
(tasks: Strings, cb?: (error?: any) => any): Orchestrator;
/**
* Start running the tasks
/** Start running the tasks
* @param tasks Tasks to be executed. You may pass any number of tasks as individual arguments.
* @param cb Callback to call after run completed.
*/
(...tasks: Strings[]/*, cb?: (error: any) => any */): Orchestrator;
//TODO: TypeScript 1.5.3 cannot express varargs followed by callback as a last argument...
// TODO: TypeScript 2.1.5 cannot express varargs followed by callback as a last argument...
(task1: Strings, task2: Strings, cb?: (error?: any) => any): Orchestrator;
(task1: Strings, task2: Strings, task3: Strings, cb?: (error?: any) => any): Orchestrator;
(task1: Strings, task2: Strings, task3: Strings, task4: Strings, cb?: (error?: any) => any): Orchestrator;
@@ -120,6 +156,23 @@ declare namespace Orchestrator {
src: string;
}
interface Task {
fn: TaskFunc;
dep: string[];
name: string;
done?: boolean;
duration?: number;
hrDuration?: [number, number];
running?: boolean;
}
interface Meta {
duration: number;
hrDuration: [number, number];
runMethod: ("callback" | "catch" | "promise" | "stream" | "sync");
}
type EventNames = ("start" | "stop" | "err" | "task_start" | "task_stop" | "task_err" | "task_not_found" | "task_recursion");
}
export = Orchestrator;

64
types/orchestrator/orchestrator-tests.ts
View File

@@ -1,10 +1,11 @@
'use strict';
import stream = require("stream");
import Q = require('q');
import Orchestrator = require('orchestrator');
var orchestrator = new Orchestrator();
// API:
//
@@ -13,60 +14,64 @@ var orchestrator = new Orchestrator();
orchestrator.add('thing1', function() {
// do stuff
});
orchestrator.add('thing2', function() {
}).add('thing2', function() {
// do stuff
});
orchestrator.add('mytask', ['array', 'of', 'task', 'names'], function() {
// Do stuff
});
orchestrator.add('thing2', function(callback: any){
orchestrator.add('thing2', function(callback){
var err: any = null;
// do stuff
callback(err);
});
import Q = require('q');
orchestrator.add('thing3', function(){
var deferred = Q.defer();
var deferred = Q.defer<void>();
// do async stuff
setTimeout(function () {
setTimeout(function() {
deferred.resolve();
}, 1);
return deferred.promise;
});
orchestrator.add('thing4', function(){
var stm = new stream.Stream();
// do stream stuff
return stm;
});
//TODO: map-stream currently not on DefinitelyTyped
//var map = require('map-stream');
//
//orchestrator.add('thing4', function(){
// var stream = map(function (args, cb) {
// cb(null, args);
// });
// // do stream stuff
// return stream;
//});
// orchestrator.task(name[, deps][, function]);
//
orchestrator.task('task1');
orchestrator.task('task2', function(cb) {
cb(null);
});
orchestrator.task('task3', ['task1', 'task2'], function() {
// do stuff
});
//
// orchestrator.hasTask(name);
//
orchestrator.hasTask('thing1');
var hasThing1: boolean = orchestrator.hasTask('thing1');
//
// orchestrator.start(tasks...[, cb]);
//
orchestrator.start('thing1', 'thing2', 'thing3', 'thing4', function (err: any) {
orchestrator.start('thing1', 'thing2', 'thing3', 'thing4', function(err: any) {
// all done
}).start(['thing1', 'thing2'], ['thing3', 'thing4'], "thing5", function(err) {
var res: any = err;
});
orchestrator.start(['thing1','thing2'], ['thing3','thing4']);
//
// orchestrator.stop()
@@ -74,16 +79,22 @@ orchestrator.start(['thing1','thing2'], ['thing3','thing4']);
orchestrator.stop();
//
// orchestrator.reset()
//
orchestrator.reset();
//
// orchestrator.on(event, cb);
//
orchestrator.on('task_start', function (e) {
orchestrator.on('task_start', function(e) {
var message: string = e.message;
var task: string = e.task;
var err: any = e.err;
});
orchestrator.on('task_stop', function (e) {
orchestrator.on('task_stop', function(e) {
var message: string = e.message;
var task: string = e.task;
var duration: number = e.duration;
@@ -93,12 +104,9 @@ orchestrator.on('task_stop', function (e) {
// orchestrator.onAll(cb);
//
orchestrator.onAll(function (e) {
orchestrator.onAll(function(e) {
var message: string = e.message;
var task: string = e.task;
var err: any = e.err;
var src: string = e.src;
});