Force Refresh / 2.1.0

Force Refresh v2.1.0

force-refresh / node_modules / handlebars / node_modules / async / wrapSync.js

wrapSync.js in Force Refresh 2.1.0, at node_modules/handlebars/node_modules/async/wrapSync.js

110 lines 3.4 KB

Raw Download Zip

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'];