Comment utiliser Promise.all avec un objet en entrée

Je travaille actuellement sur un petit jeu en 2D de la bibliothèque pour mon propre usage, et j'ai couru dans un peu d'un problème. Il y a une fonction particulière dans la bibliothèque appelée loadGame qui prend la dépendance info en entrée (les fichiers de ressources, et une liste de scripts ot être exécuté). Voici un exemple.

loadGame({
    "root" : "/source/folder/for/game/",

    "resources" : {
        "soundEffect" : "audio/sound.mp3",
        "someImage" : "images/something.png",
        "someJSON" : "json/map.json"
    },

    "scripts" : [
        "js/helperScript.js",
        "js/mainScript.js"
    ]
})

Chaque élément de ressources a une clé qui est utilisée par le jeu pour accéder à cette ressource particulière. Le loadGame fonction convertit les ressources dans un objet de promesses.

Le problème, c'est qu'il essaie d'utiliser des Promesses.tous à vérifier quand ils sont tous prêts, mais la Promesse.tous n'accepte que les iterables comme entrées - si un objet comme ce que j'ai est hors de question.

J'ai donc essayé de convertir l'objet dans un tableau, cela fonctionne très bien, sauf que chaque ressource est juste un élément dans un tableau et n'ont pas de clé pour les identifier.

Voici le code pour loadGame:

var loadGame = function (game) {
    return new Promise(function (fulfill, reject) {
        //the root folder for the game
        var root = game.root || '';

        //these are the types of files that can be loaded
        //getImage, getAudio, and getJSON are defined elsewhere in my code - they return promises
        var types = {
            jpg : getImage,
            png : getImage,
            bmp : getImage,

            mp3 : getAudio,
            ogg : getAudio,
            wav : getAudio,

            json : getJSON
        };

        //the object of promises is created using a mapObject function I made
        var resources = mapObject(game.resources, function (path) {
            //get file extension for the item
            var extension = path.match(/(?:\.([^.]+))?$/)[1];

            //find the correct 'getter' from types
            var get = types[extension];

            //get it if that particular getter exists, otherwise, fail
            return get ? get(root + path) :
                reject(Error('Unknown resource type "' + extension + '".'));
        });

        //load scripts when they're done
        //this is the problem here
        //my 'values' function converts the object into an array
        //but now they are nameless and can't be properly accessed anymore
        Promise.all(values(resources)).then(function (resources) {
            //sequentially load scripts
            //maybe someday I'll use a generator for this
            var load = function (i) {
                //load script
                getScript(root + game.scripts[i]).then(function () {
                    //load the next script if there is one
                    i++;

                    if (i < game.scripts.length) {
                        load(i);
                    } else {
                        //all done, fulfill the promise that loadGame returned
                        //this is giving an array back, but it should be returning an object full of resources
                        fulfill(resources);
                    }
                });
            };

            //load the first script
            load(0);
        });
    });
};

Idéalement, j'aimerais un moyen de bien gérer une liste de promesses pour les ressources, tandis que toujours maintenir un identifiant pour chaque élément. Toute aide serait appréciée, merci.

source d'informationauteur Matt