05b22d2597
This commit introduces 4 changes:
1) Function declarations are wrapped using function declarations.
This has two advantages:
- We can rely on native hoisting, instead of using _blockHoist
- The function isn't wrapped until it is called. This avoids
problems where `regeneratorRuntime.wrap` was called before
that `babel-polyfill` was imported.
Example:
function fn() {}
// becomes
function fn() { return _fn.apply(this, arguments); }
function _fn() {
_fn = _wrapper(/* Original function ... */);
return _fn.apply(this, arguments);
}
2) Use a single template for both named and anonymous function
expressions. They already had the same behavior, but the one
used for named functions was a bit longer.
3) Use normal functions instead of arrow functions to wrap
function expressions.
4) Generate a name based on the original one for wrapped
functions (e.g. `foo` becomes `_foo` instead of `_ref`).
31 lines
2.1 KiB
JavaScript
31 lines
2.1 KiB
JavaScript
function _skipFirstGeneratorNext(fn) { return function () { var it = fn.apply(this, arguments); it.next(); return it; }; }
|
|
|
|
function _awaitAsyncGenerator(value) { return new _AwaitValue(value); }
|
|
|
|
function _wrapAsyncGenerator(fn) { return function () { return new _AsyncGenerator(fn.apply(this, arguments)); }; }
|
|
|
|
function _AsyncGenerator(gen) { var front, back; function send(key, arg) { return new Promise(function (resolve, reject) { var request = { key: key, arg: arg, resolve: resolve, reject: reject, next: null }; if (back) { back = back.next = request; } else { front = back = request; resume(key, arg); } }); } function resume(key, arg) { try { var result = gen[key](arg); var value = result.value; var wrappedAwait = value instanceof _AwaitValue; Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) { if (wrappedAwait) { resume("next", arg); return; } settle(result.done ? "return" : "normal", arg); }, function (err) { resume("throw", err); }); } catch (err) { settle("throw", err); } } function settle(type, value) { switch (type) { case "return": front.resolve({ value: value, done: true }); break; case "throw": front.reject(value); break; default: front.resolve({ value: value, done: false }); break; } front = front.next; if (front) { resume(front.key, front.arg); } else { back = null; } } this._invoke = send; if (typeof gen.return !== "function") { this.return = undefined; } }
|
|
|
|
if (typeof Symbol === "function" && Symbol.asyncIterator) { _AsyncGenerator.prototype[Symbol.asyncIterator] = function () { return this; }; }
|
|
|
|
_AsyncGenerator.prototype.next = function (arg) { return this._invoke("next", arg); };
|
|
|
|
_AsyncGenerator.prototype.throw = function (arg) { return this._invoke("throw", arg); };
|
|
|
|
_AsyncGenerator.prototype.return = function (arg) { return this._invoke("return", arg); };
|
|
|
|
function _AwaitValue(value) { this.wrapped = value; }
|
|
|
|
function foo() {
|
|
return _foo.apply(this, arguments);
|
|
}
|
|
|
|
function _foo() {
|
|
_foo = _wrapAsyncGenerator(_skipFirstGeneratorNext(function* () {
|
|
let _functionSent = yield;
|
|
|
|
_functionSent = yield _awaitAsyncGenerator(_functionSent);
|
|
}));
|
|
return _foo.apply(this, arguments);
|
|
}
|