|
|
"use strict";
// These use the global symbol registry so that multiple copies of this
// library can work together in case they are not deduped.
const GENSYNC_START = Symbol.for("gensync:v1:start"); const GENSYNC_SUSPEND = Symbol.for("gensync:v1:suspend");
const GENSYNC_EXPECTED_START = "GENSYNC_EXPECTED_START"; const GENSYNC_EXPECTED_SUSPEND = "GENSYNC_EXPECTED_SUSPEND"; const GENSYNC_OPTIONS_ERROR = "GENSYNC_OPTIONS_ERROR"; const GENSYNC_RACE_NONEMPTY = "GENSYNC_RACE_NONEMPTY"; const GENSYNC_ERRBACK_NO_CALLBACK = "GENSYNC_ERRBACK_NO_CALLBACK";
module.exports = Object.assign( function gensync(optsOrFn) { let genFn = optsOrFn; if (typeof optsOrFn !== "function") { genFn = newGenerator(optsOrFn); } else { genFn = wrapGenerator(optsOrFn); }
return Object.assign(genFn, makeFunctionAPI(genFn)); }, { all: buildOperation({ name: "all", arity: 1, sync: function(args) { const items = Array.from(args[0]); return items.map(item => evaluateSync(item)); }, async: function(args, resolve, reject) { const items = Array.from(args[0]);
if (items.length === 0) { Promise.resolve().then(() => resolve([])); return; }
let count = 0; const results = items.map(() => undefined); items.forEach((item, i) => { evaluateAsync( item, val => { results[i] = val; count += 1;
if (count === results.length) resolve(results); }, reject ); }); }, }), race: buildOperation({ name: "race", arity: 1, sync: function(args) { const items = Array.from(args[0]); if (items.length === 0) { throw makeError("Must race at least 1 item", GENSYNC_RACE_NONEMPTY); }
return evaluateSync(items[0]); }, async: function(args, resolve, reject) { const items = Array.from(args[0]); if (items.length === 0) { throw makeError("Must race at least 1 item", GENSYNC_RACE_NONEMPTY); }
for (const item of items) { evaluateAsync(item, resolve, reject); } }, }), } );
/** * Given a generator function, return the standard API object that executes * the generator and calls the callbacks. */ function makeFunctionAPI(genFn) { const fns = { sync: function(...args) { return evaluateSync(genFn.apply(this, args)); }, async: function(...args) { return new Promise((resolve, reject) => { evaluateAsync(genFn.apply(this, args), resolve, reject); }); }, errback: function(...args) { const cb = args.pop(); if (typeof cb !== "function") { throw makeError( "Asynchronous function called without callback", GENSYNC_ERRBACK_NO_CALLBACK ); }
let gen; try { gen = genFn.apply(this, args); } catch (err) { cb(err); return; }
evaluateAsync(gen, val => cb(undefined, val), err => cb(err)); }, }; return fns; }
function assertTypeof(type, name, value, allowUndefined) { if ( typeof value === type || (allowUndefined && typeof value === "undefined") ) { return; }
let msg; if (allowUndefined) { msg = `Expected opts.${name} to be either a ${type}, or undefined.`; } else { msg = `Expected opts.${name} to be a ${type}.`; }
throw makeError(msg, GENSYNC_OPTIONS_ERROR); } function makeError(msg, code) { return Object.assign(new Error(msg), { code }); }
/** * Given an options object, return a new generator that dispatches the * correct handler based on sync or async execution. */ function newGenerator({ name, arity, sync, async, errback }) { assertTypeof("string", "name", name, true /* allowUndefined */); assertTypeof("number", "arity", arity, true /* allowUndefined */); assertTypeof("function", "sync", sync); assertTypeof("function", "async", async, true /* allowUndefined */); assertTypeof("function", "errback", errback, true /* allowUndefined */); if (async && errback) { throw makeError( "Expected one of either opts.async or opts.errback, but got _both_.", GENSYNC_OPTIONS_ERROR ); }
if (typeof name !== "string") { let fnName; if (errback && errback.name && errback.name !== "errback") { fnName = errback.name; } if (async && async.name && async.name !== "async") { fnName = async.name.replace(/Async$/, ""); } if (sync && sync.name && sync.name !== "sync") { fnName = sync.name.replace(/Sync$/, ""); }
if (typeof fnName === "string") { name = fnName; } }
if (typeof arity !== "number") { arity = sync.length; }
return buildOperation({ name, arity, sync: function(args) { return sync.apply(this, args); }, async: function(args, resolve, reject) { if (async) { async.apply(this, args).then(resolve, reject); } else if (errback) { errback.call(this, ...args, (err, value) => { if (err == null) resolve(value); else reject(err); }); } else { resolve(sync.apply(this, args)); } }, }); }
function wrapGenerator(genFn) { return setFunctionMetadata(genFn.name, genFn.length, function(...args) { return genFn.apply(this, args); }); }
function buildOperation({ name, arity, sync, async }) { return setFunctionMetadata(name, arity, function*(...args) { const resume = yield GENSYNC_START; if (!resume) { // Break the tail call to avoid a bug in V8 v6.X with --harmony enabled.
const res = sync.call(this, args); return res; }
let result; try { async.call( this, args, value => { if (result) return;
result = { value }; resume(); }, err => { if (result) return;
result = { err }; resume(); } ); } catch (err) { result = { err }; resume(); }
// Suspend until the callbacks run. Will resume synchronously if the
// callback was already called.
yield GENSYNC_SUSPEND;
if (result.hasOwnProperty("err")) { throw result.err; }
return result.value; }); }
function evaluateSync(gen) { let value; while (!({ value } = gen.next()).done) { assertStart(value, gen); } return value; }
function evaluateAsync(gen, resolve, reject) { (function step() { try { let value; while (!({ value } = gen.next()).done) { assertStart(value, gen);
// If this throws, it is considered to have broken the contract
// established for async handlers. If these handlers are called
// synchronously, it is also considered bad behavior.
let sync = true; let didSyncResume = false; const out = gen.next(() => { if (sync) { didSyncResume = true; } else { step(); } }); sync = false;
assertSuspend(out, gen);
if (!didSyncResume) { // Callback wasn't called synchronously, so break out of the loop
// and let it call 'step' later.
return; } }
return resolve(value); } catch (err) { return reject(err); } })(); }
function assertStart(value, gen) { if (value === GENSYNC_START) return;
throwError( gen, makeError( `Got unexpected yielded value in gensync generator: ${JSON.stringify( value )}. Did you perhaps mean to use 'yield*' instead of 'yield'?`,
GENSYNC_EXPECTED_START ) ); } function assertSuspend({ value, done }, gen) { if (!done && value === GENSYNC_SUSPEND) return;
throwError( gen, makeError( done ? "Unexpected generator completion. If you get this, it is probably a gensync bug." : `Expected GENSYNC_SUSPEND, got ${JSON.stringify( value )}. If you get this, it is probably a gensync bug.`,
GENSYNC_EXPECTED_SUSPEND ) ); }
function throwError(gen, err) { // Call `.throw` so that users can step in a debugger to easily see which
// 'yield' passed an unexpected value. If the `.throw` call didn't throw
// back to the generator, we explicitly do it to stop the error
// from being swallowed by user code try/catches.
if (gen.throw) gen.throw(err); throw err; }
function isIterable(value) { return ( !!value && (typeof value === "object" || typeof value === "function") && !value[Symbol.iterator] ); }
function setFunctionMetadata(name, arity, fn) { if (typeof name === "string") { // This should always work on the supported Node versions, but for the
// sake of users that are compiling to older versions, we check for
// configurability so we don't throw.
const nameDesc = Object.getOwnPropertyDescriptor(fn, "name"); if (!nameDesc || nameDesc.configurable) { Object.defineProperty( fn, "name", Object.assign(nameDesc || {}, { configurable: true, value: name, }) ); } }
if (typeof arity === "number") { const lengthDesc = Object.getOwnPropertyDescriptor(fn, "length"); if (!lengthDesc || lengthDesc.configurable) { Object.defineProperty( fn, "length", Object.assign(lengthDesc || {}, { configurable: true, value: arity, }) ); } }
return fn; }
|