ES2015 equivalent of $ .Deferred ()

Question

I am using Babel for a project and I am stuck in a very simple problem. I'm very used to jQuery Pending Objects, and I'm struggling to find its equivalent to ES2015, here is what I basically want:

// file1.js
let dfd = new Promise()

function functionCalledAtSomePoint(thing) {
    dfd.resolve(thing)
}

export default { dfd }


// file2.js
import { dfd } from './file1'

dfd.then((thing) => {
    console.log('Yay thing:', thing)
})

What should be the right path for this simple delayed one?

EDIT with royhowie's answer:

// file1.js
let thing
function getThing(_thing) {
    return new Promise((resolve) => {
        if (el) {
            thing = new Thing(el)
        }
        resolve(thing)
    })
}

function functionCalledAtSomePoint(el) {
    getThing(el)
}

export default { getThing }


// file2.js
import { getThing } from './file1'

getThing.then((thing) => {
    console.log('Yay thing:', thing)
})

Answer 1

You can export the promise directly (instead of a function) - for example, you have one - but then you can use it ( .then) once, which is probably not what you want.

Instead, you should export a function that returns Promise:

1.js file

import User from '../models/user'

export function getUsersFromDatabase () {
    return new Promise((resolve, reject) => {
        User.find({}, (err, users) => {
            return err ? reject(err) : resolve(users)
        })
    })
}

file2.js

import { getUsersFromDatabase } from './file1'

getUsersFromDatabase().then((users) => {
    // success
}).catch((err) => {
    // no users
})

Promise , , , bluebird ( ).

Answer 2

jQuery , ES2015

,

function makeDeferred() {
    var res, rej;
    let dfd = new Promise(function(resolve, reject) {
        res = resolve;
        rej = reject;
    });
    dfd.resolve = res;
    dfd.reject = rej;
    return dfd;
}
let dfd = makeDeferred();

, kludge, ( - , ,

Answer 3

Promise, resolve(value). , jQuery.deferred().

function DeferredPromise() {
    var _resolve = null;
    var _reject = null;

    this.promise = new Promise(function(resolve, reject) {
        _resolve = resolve;
        _reject = reject;
    });
    this.then = function() {
        return this.promise.then(...arguments);
    }
    this.catch = function() {
        return this.promise.catch(...arguments);
    }
    this.resolve = function() {
        _resolve(...arguments);
    }
    this.reject = function() {
        _reject(...arguments);
    }
}

DeferredPromise:

var p = new DeferredPromise();

:

p.then(val => {
    console.log('val(1)', val);
})

Maybe wait for it again, you can also link it using the usual one Promise:

p.then(val => {
    console.log('val(2)', val);
    return 42;
 }).then(val => {
    console.log('.then(somethingElse)', val);
 })
 .catch(err => { console.error('err', err); })

And allow it whenever you want:

p.resolve({ username: 'Luke.Skywalker', age: 42 });