From 60546f7981f70a248b798dfeb6ffe3d5eb99650d Mon Sep 17 00:00:00 2001 From: Boris Yankov Date: Mon, 22 Oct 2012 03:39:43 +0300 Subject: [PATCH] Initial async declarations and tests --- Definitions/async-0.1.d.ts | 48 ++++++++ Tests/async-tests.ts | 228 +++++++++++++++++++++++++++++++++++++ 2 files changed, 276 insertions(+) create mode 100644 Definitions/async-0.1.d.ts create mode 100644 Tests/async-tests.ts diff --git a/Definitions/async-0.1.d.ts b/Definitions/async-0.1.d.ts new file mode 100644 index 000000000..6bd5ca235 --- /dev/null +++ b/Definitions/async-0.1.d.ts @@ -0,0 +1,48 @@ +// Type definitions for Async 0.1 +// Project: https://github.com/caolan/async +// Definitions: https://github.com/borisyankov/DefinitelyTyped + + +declare module async { + + export interface Errback { (err: string): any; } + + // Collections + export function forEach(arr: any[], iterator: (item, callback: Function) => void, callback: Errback): void; + export function forEachSeries(arr: any[], iterator: (item, callback: Function) => void , callback: Errback): void; + export function forEachLimit(arr, limit, iterator, callback); + export function map(arr, iterator, callback); + export function mapSeries(arr, iterator, callback); + export function filter(arr, iterator, callback); + export function filterSeries(arr, iterator, callback); + export function reject(arr, iterator, callback); + export function rejectSeries(arr, iterator, callback); + export function reduce(arr, memo, iterator, callback); + export function reduceRight(arr, memo, iterator, callback); + export function detect(arr, iterator, callback); + export function detectSeries(arr, iterator, callback); + export function sortBy(arr, iterator, callback); + export function some(arr, iterator, callback); + export function every(arr, iterator, callback); + export function concat(arr, iterator, callback); + export function concatSeries(arr, iterator, callback); + + // Control Flow + export function series(tasks, callback? ); + export function parallel(tasks, callback? ); + export function whilst(test, fn, callback); + export function until(test, fn, callback); + export function waterfall(tasks, callback? ); + export function queue(worker, concurrency); + export function auto(tasks, callback? ); + export function iterator(tasks); + export function apply(fn, ...arguments: any[]); + export function nextTick(callback); + + // Utils + export function memoize(fn, hasher? ); + export function unmemoize(fn); + export function log(fn, ...arguments: any[]); + export function dir(fn, ...arguments: any[]); + export function noConflict(); +} diff --git a/Tests/async-tests.ts b/Tests/async-tests.ts new file mode 100644 index 000000000..a0d5bbea9 --- /dev/null +++ b/Tests/async-tests.ts @@ -0,0 +1,228 @@ +/// + +var fs, path; + +//import "async"; + +async.map(['file1', 'file2', 'file3'], fs.stat, function (err, results) { }); + +async.filter(['file1', 'file2', 'file3'], path.exists, function (results) { }); + +async.parallel([ + function () { }, + function () { } +], callback); + +async.series([ + function () { }, + function () { } +]); + +async.map(data, asyncProcess, function (err, results) { + alert(results); +}); + +async.forEach(openFiles, saveFile, function (err) { }); + +async.forEachLimit(documents, 20, requestApi, function (err) { }); + +async.map(['file1', 'file2', 'file3'], fs.stat, function (err, results) { }); + +async.filter(['file1', 'file2', 'file3'], path.exists, function (results) { }); + +async.reduce([1, 2, 3], 0, function (memo, item, callback) { + process.nextTick(function () { + callback(null, memo + item) + }); +}, function (err, result) { }); + +async.detect(['file1', 'file2', 'file3'], path.exists, function (result) { }); + +async.sortBy(['file1', 'file2', 'file3'], function (file, callback) { + fs.stat(file, function (err, stats) { + callback(err, stats.mtime); + }); +}, function (err, results) { }); + +async.some(['file1', 'file2', 'file3'], path.exists, function (result) { }); + +async.every(['file1', 'file2', 'file3'], path.exists, function (result) { }); + +async.concat(['dir1', 'dir2', 'dir3'], fs.readdir, function (err, files) { }); + +async.series([ + function (callback) { + callback(null, 'one'); + }, + function (callback) { + callback(null, 'two'); + }, +], +function (err, results) { }); + + + +async.series({ + one: function (callback) { + setTimeout(function () { + callback(null, 1); + }, 200); + }, + two: function (callback) { + setTimeout(function () { + callback(null, 2); + }, 100); + }, +}, +function (err, results) { }); + +async.parallel([ + function (callback) { + setTimeout(function () { + callback(null, 'one'); + }, 200); + }, + function (callback) { + setTimeout(function () { + callback(null, 'two'); + }, 100); + }, +], +function (err, results) { }); + + +async.parallel({ + one: function (callback) { + setTimeout(function () { + callback(null, 1); + }, 200); + }, + two: function (callback) { + setTimeout(function () { + callback(null, 2); + }, 100); + }, +}, +function (err, results) { }); + + +var count = 0; + +async.whilst( + function () { return count < 5; }, + function (callback) { + count++; + setTimeout(callback, 1000); + }, + function (err) { } +); + + +async.waterfall([ + function (callback) { + callback(null, 'one', 'two'); + }, + function (arg1, arg2, callback) { + callback(null, 'three'); + }, + function (arg1, callback) { + callback(null, 'done'); + } +], function (err, result) { }); + + +var q = async.queue(function (task, callback) { + console.log('hello ' + task.name); + callback(); +}, 2); + + +q.drain = function () { + console.log('all items have been processed'); +} + +q.push({ name: 'foo' }, function (err) { + console.log('finished processing foo'); +}); +q.push({ name: 'bar' }, function (err) { + console.log('finished processing bar'); +}); + +q.push([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], function (err) { + console.log('finished processing bar'); +}); + + +async.auto({ + get_data: function (callback) { }, + make_folder: function (callback) { }, + write_file: ['get_data', 'make_folder', function (callback) { + callback(null, filename); + }], + email_link: ['write_file', function (callback, results) { }] +}); + + +async.parallel([ + function (callback) { }, + function (callback) { } +], +function (results) { + async.series([ + function (callback) { + }, + email_link: function(callback) { } + ]); +}); + + +var iterator = async.iterator([ + function () { sys.p('one'); }, + function () { sys.p('two'); }, + function () { sys.p('three'); } +]); + +async.parallel([ + async.apply(fs.writeFile, 'testfile1', 'test1'), + async.apply(fs.writeFile, 'testfile2', 'test2'), +]); + + +async.parallel([ + function (callback) { + fs.writeFile('testfile1', 'test1', callback); + }, + function (callback) { + fs.writeFile('testfile2', 'test2', callback); + }, +]); + +var call_order = []; +async.nextTick(function () { + call_order.push('two'); + // call_order now equals ['one','two] +}); +call_order.push('one'); + + +var slow_fn = function (name, callback) { + callback(null, result); +}; +var fn = async.memoize(slow_fn); + +// fn can now be used as if it were slow_fn +fn('some name', function () { + // callback +}); + +var hello = function (name, callback) { + setTimeout(function () { + callback(null, 'hello ' + name); + }, 1000); +}; + +var hello = function (name, callback) { + setTimeout(function () { + callback(null, { hello: name }); + }, 1000); +}; \ No newline at end of file