Projekt

Obecné

Profil

Stáhnout (3.42 KB) Statistiky
| Větev: | Revize:
1
'use strict';
2

    
3
Object.defineProperty(exports, "__esModule", {
4
    value: true
5
});
6
exports.default = asyncify;
7

    
8
var _isObject = require('lodash/isObject');
9

    
10
var _isObject2 = _interopRequireDefault(_isObject);
11

    
12
var _initialParams = require('./internal/initialParams');
13

    
14
var _initialParams2 = _interopRequireDefault(_initialParams);
15

    
16
var _setImmediate = require('./internal/setImmediate');
17

    
18
var _setImmediate2 = _interopRequireDefault(_setImmediate);
19

    
20
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
21

    
22
/**
23
 * Take a sync function and make it async, passing its return value to a
24
 * callback. This is useful for plugging sync functions into a waterfall,
25
 * series, or other async functions. Any arguments passed to the generated
26
 * function will be passed to the wrapped function (except for the final
27
 * callback argument). Errors thrown will be passed to the callback.
28
 *
29
 * If the function passed to `asyncify` returns a Promise, that promises's
30
 * resolved/rejected state will be used to call the callback, rather than simply
31
 * the synchronous return value.
32
 *
33
 * This also means you can asyncify ES2017 `async` functions.
34
 *
35
 * @name asyncify
36
 * @static
37
 * @memberOf module:Utils
38
 * @method
39
 * @alias wrapSync
40
 * @category Util
41
 * @param {Function} func - The synchronous function, or Promise-returning
42
 * function to convert to an {@link AsyncFunction}.
43
 * @returns {AsyncFunction} An asynchronous wrapper of the `func`. To be
44
 * invoked with `(args..., callback)`.
45
 * @example
46
 *
47
 * // passing a regular synchronous function
48
 * async.waterfall([
49
 *     async.apply(fs.readFile, filename, "utf8"),
50
 *     async.asyncify(JSON.parse),
51
 *     function (data, next) {
52
 *         // data is the result of parsing the text.
53
 *         // If there was a parsing error, it would have been caught.
54
 *     }
55
 * ], callback);
56
 *
57
 * // passing a function returning a promise
58
 * async.waterfall([
59
 *     async.apply(fs.readFile, filename, "utf8"),
60
 *     async.asyncify(function (contents) {
61
 *         return db.model.create(contents);
62
 *     }),
63
 *     function (model, next) {
64
 *         // `model` is the instantiated model object.
65
 *         // If there was an error, this function would be skipped.
66
 *     }
67
 * ], callback);
68
 *
69
 * // es2017 example, though `asyncify` is not needed if your JS environment
70
 * // supports async functions out of the box
71
 * var q = async.queue(async.asyncify(async function(file) {
72
 *     var intermediateStep = await processFile(file);
73
 *     return await somePromise(intermediateStep)
74
 * }));
75
 *
76
 * q.push(files);
77
 */
78
function asyncify(func) {
79
    return (0, _initialParams2.default)(function (args, callback) {
80
        var result;
81
        try {
82
            result = func.apply(this, args);
83
        } catch (e) {
84
            return callback(e);
85
        }
86
        // if result is Promise object
87
        if ((0, _isObject2.default)(result) && typeof result.then === 'function') {
88
            result.then(function (value) {
89
                invokeCallback(callback, null, value);
90
            }, function (err) {
91
                invokeCallback(callback, err.message ? err : new Error(err));
92
            });
93
        } else {
94
            callback(null, result);
95
        }
96
    });
97
}
98

    
99
function invokeCallback(callback, error, value) {
100
    try {
101
        callback(error, value);
102
    } catch (e) {
103
        (0, _setImmediate2.default)(rethrow, e);
104
    }
105
}
106

    
107
function rethrow(error) {
108
    throw error;
109
}
110
module.exports = exports['default'];
(105-105/105)