hybridables / redolent Goto Github PK

var fn = redolent(function (done) {
  return 'foo bar'
})

fn().catch(function (err) {
  console.log(err)
})

var fn = redolent(function (done) {
  return
})

var fn = redolent(function (done) {
  return undefined
})

if (isAsyncFn && !called && !isPromise(syncResult)) {
  var msg = 'async function need to call `done/cb` callback argument or return a Promise'
  reject(new Error('redolent: ' + msg))
}

var fn = redolent(function (foo, done) {
  console.log('foo is', foo)
  // done is not called nor Promise is returned,
  // so when `fn` is called it will return rejected promise 
})

fn(123).catch(console.log)

if (isAsyncFn && !called && isPromise(syncResult)) {
  resolve(syncResult)
}

      if ((!isAsyncFn && !called) || (isAsyncFn && !called && isPromise(syncResult))) {
        resolve(syncResult);
      }

var fn = redolent(function * () {return yield args})
fn(1, 2, 3).then(console.log) // => [1, 2, 3]

var PromiseCtor = redolent.load()
// or
var PromiseCtor = redolent.load(require('bluebird')) // or some other promise

function loadPromise (Promize) {
  var promCtor = index$10 || Promize
  if (typeof promCtor !== 'function') {
    throw new TypeError('redolent: no native Promise support and no opts.Promise')
  }
  return promCtor
}

var index = function redolent (fn, opts) {
  if (typeof fn !== 'function') {
    throw new TypeError('redolent: expect `fn` to be a function')
  }

  opts = index$6({
    context: this,
    Promise: index$10
  }, opts);
  opts.Promise = loadPromise(opts.Promise)


  module.exports.Promise = opts.Promise
  redolent.Promise = opts.Promise
  index.Promise = opts.Promise

  return function () {
    opts.context = this || opts.context;
    opts.args = index$2(opts.args).concat(index$4(arguments));

    // if (typeof opts.Promise !== 'function') {
    //   throw new TypeError('redolent: no native Promise support and no opts.Promise')
    // }

    var promise = new opts.Promise(function (resolve, reject) {
      var called = false;

      function done (er, res) {
        called = true;
        if (er) {
          return reject(er)
        }
        if (arguments.length > 2) {
          res = index$4(arguments, 1);
        }
        return resolve(res)
      }

      var isAsyncFn = index$12(fn);

      opts.args = isAsyncFn ? opts.args.concat(done) : opts.args;
      var syncResult = fn.apply(opts.context, opts.args);

      if (!isAsyncFn && !called) {
        resolve(syncResult);
      }
    });

    return normalize(promise, index$10)
  }
};

function normalize (promise, isNativeSupported) {
  promise.___nativePromise = Boolean(isNativeSupported);
  promise.___customPromise = !promise.___nativePromise;
  return promise
}

index.load = loadPromise
module.exports = index;