Wrapped Overwolf's overwolf.windows methods in promises for use in ES6/7

overwolf.windows.js

export function getCurrentWindow() {
    return new Promise((resolve, reject) => {
        overwolf.windows.getCurrentWindow(res => {
            resolve(res);
        });
    });
}

export function obtainDeclaredWindow(win) {
    return new Promise((resolve, reject) => {
        overwolf.windows.obtainDeclaredWindow(win, res => {
            resolve(res);
        });
    });
}

export function dragMove(id) {
    return new Promise((resolve, reject) => {
        overwolf.windows.dragMove(id, res => {
            resolve(res);
        });
    });
}

export function dragResize(id, edge) {
    return overwolf.windows.dragResize(id, edge);
}

export function changeSize(id, width, height) {
    return new Promise((resolve, reject) => {
        overwolf.windows.changeSize(id, width, height, res => {
            resolve(res);
        });
    });
}

export function changePosition(id, left, top) {
    return new Promise((resolve, reject) => {
        overwolf.windows.changePosition(id, left, top, res => {
            resolve(res);
        });
    });
}

export function close(id) {
    return new Promise((resolve, reject) => {
        overwolf.windows.close(id, res => {
            resolve(res);
        });
    });
}

export function minimize(id) {
    return new Promise((resolve, reject) => {
        overwolf.windows.minimize(id, res => {
            resolve(res);
        });
    });
}

export function maximize(id) {
    return new Promise((resolve, reject) => {
        overwolf.windows.maximize(id, res => {
            resolve(res);
        });
    });
}

export function restore(id) {
    return new Promise((resolve, reject) => {
        overwolf.windows.restore(id, res => {
            resolve(res);
        });
    });
}

export function getWindowState(id) {
    return new Promise((resolve, reject) => {
        overwolf.windows.getWindowState(id, res => {
            resolve(res);
        });
    });
}

export function openOptionsPage() {
    return new Promise((resolve, reject) => {
        overwolf.windows.openOptionsPage(res => {
            resolve(res);
        });
    });
}

export function setDesktopOnly(id, shouldBeDesktopOnly) {
    return new Promise((resolve, reject) => {
        overwolf.windows.setDesktopOnly(id, shouldBeDesktopOnly, res => {
            resolve(res);
        });
    });
}

export function setRestoreAnimationsEnabled(id, shouldEnableAnimations) {
    return new Promise((resolve, reject) => {
        overwolf.windows.setRestoreAnimationsEnabled(id, shouldEnableAnimations, res => {
            resolve(res);
        });
    });
}

export function setTopMost(id, shouldBeTopMost) {
    return new Promise((resolve, reject) => {
        overwolf.windows.setTopMost(id, shouldBeTopMost, res => {
            resolve(res);
        });
    });
}

export class MediaPlayerElement {
    create(x, y, width, height) {
        return new Promise((resolve, reject) => {
            overwolf.windows.mediaPlayerElement.create(x, y, width, height, res => {
                resolve(res);
            });
        });
    }

    setBounds(x, y, width, height) {
        return new Promise((resolve, reject) => {
            overwolf.windows.mediaPlayerElement.setBounds(x, y, width, height, res => {
                resolve(res);
            });
        });
    }

    setVideo(url) {
        return new Promise((resolve, reject) => {
            overwolf.windows.mediaPlayerElement.setVideo(url, res => {
                resolve(res);
            });
        });
    }

    play() {
        return new Promise((resolve, reject) => {
            overwolf.windows.mediaPlayerElement.play(res => {
                resolve(res);
            });
        });
    }

    pause() {
        return new Promise((resolve, reject) => {
            overwolf.windows.mediaPlayerElement.pause(res => {
                resolve(res);
            });
        });
    }

    resume() {
        return new Promise((resolve, reject) => {
            overwolf.windows.mediaPlayerElement.resume(res => {
                resolve(res);
            });
        });
    }

    setVolume(volume) {
        return new Promise((resolve, reject) => {
            overwolf.windows.mediaPlayerElement.setVolume(volume, res => {
                resolve(res);
            });
        });
    }

    stop() {
        return new Promise((resolve, reject) => {
            overwolf.windows.mediaPlayerElement.stop(res => {
                resolve(res);
            });
        });
    }

    seek(seconds) {
        return new Promise((resolve, reject) => {
            overwolf.windows.mediaPlayerElement.seek(seconds, res => {
                resolve(res);
            });
        });
    }

    getProgress() {
        return new Promise((resolve, reject) => {
            overwolf.windows.mediaPlayerElement.getProgress(res => {
                resolve(res);
            });
        });
    }
}

export default {
    getCurrentWindow,
    obtainDeclaredWindow,
    dragMove,
    dragResize,
    changeSize,
    changePosition,
    close,
    minimize,
    maximize,
    restore,
    getWindowState,
    openOptionsPage,
    setDesktopOnly,
    setRestoreAnimationsEnabled,
    setTopMost,
};

note: export default does not include the mediaPlayerElement.

ES6 Example:

import OW from 'overwolf.windows.js';

function dragWindow() {
    OW.getCurrentWindow();
    .then(function(res) {
        OW.dragMove(res.window.id);
    });
}

ES7 Example:

import OW from 'overwolf.windows.js';

async function dragWindow() {
    let result = await OW.getCurrentWindow();
    OW.dragMove(result.window.id);
}