Configurazione dei moduli con RequireJS quando config dipende da RequireJS

Question

Ci scusiamo se ho perso questo nei documenti. Fondamentalmente voglio usare la funzionalità di configurazione del modulo RequireJS. Vorrei gestire centralmente i valori di configurazione dati ai moduli in un pacchetto.

Questo è un esempio dalla documentazione:

requirejs.config({ 
    config: { 
     'bar': { 
      size: 'large' 
     }, 
     'baz': { 
      color: 'blue' 
     } 
    } 
}); 

//bar.js, which uses simplified CJS wrapping: 
define(function (require, exports, module) { 
    //Will be the value 'large' 
    var size = module.config().size; 
}); 

//baz.js which uses a dependency array, 
define(['module'], function (module) { 
    //Will be the value 'blue' 
    var color = module.config().color; 
}); 

Il mio problema è che il mio informazioni di configurazione sarà un po 'più complesso, e avrà per sé avere dipendenze. Vorrei:

requirejs.config({ 
    config: { 
     'bar': { 
      path: path.dirname(module.uri) 
      key: crypto.randomBytes(64) 
     }, 
    } 
}); 

Dove le variabili nella mia configurazione devono utilizzare requireJS per valutare.

Per me avrebbe senso che ci fosse una separazione logica tra la configurazione RequireJS - la configurazione necessaria per caricare i moduli - e la configurazione del modulo dell'utente. Ma Attualmente sto lottando per trovare questo :(

Answer 1

Dopo aver pensato a questo un po 'più mi sono venuti con una soluzione. Non è particolarmente carino ma sembra funzionare.

Io semplicemente requireJS (...) due volte, prima di creare la configurazione, e la seconda a caricare i moduli applicativi con la configurazione ..

requireJSConfig = 
    baseUrl: __dirname 
    nodeRequire: require 

# Create the require function with basic config 
requireJS = require('requirejs').config(requireJSConfig) 
requireJS ['module', 'node.extend', 'crypto', 'path'], (module, extend, crypto, path) -> 
    # Application configuration 
    appConfig = 
     'bar': 
      path: path.dirname(module.uri) 
      key: crypto.randomBytes(64) # for doing cookie encryption 

    # get a new requireJS function with CONFIG data 
    requireJS = require('requirejs').config(extend(requireJSConfig, config: appConfig)) 
    requireJS ['bar'], (app) -> 
     ### 
      Load and start the server 
     ### 
     appServer = new app() 

     # And start the app on that interface (and port). 
     appServer.start() 

E in bar.coffee

# bar.coffee 
define ['module'], (module) -> 
    # config is now available in this module 
    console.log(module.config().key) 

Answer 2

Penso che il modo corretto per farlo è quello di fare un modulo di configurazione ...

// config.js 
define(['module', 'path', 'crypto'], function(module, path, crypto) { 
    return { 
     path: path.dirname(module.uri) 
     key: crypto.randomBytes(64) 
    }; 
}); 

Poi utilizzarlo in altri moduli ...

// bar.js 
define(['config'], function (config) { 
    var key = config.key; 
}); 

è quindi possibile rendere così complicato come ti piace

EDIT: si potrebbe inquinare il namespace globale per questa classe speciale ...

define(['module', 'path', 'crypto'], function(module, path, crypto) { 
    window.config = { 
     path: path.dirname(module.uri) 
     key: crypto.randomBytes(64) 
    }; 
}); 

aggiungerlo al livello superiore richiede chiamata:

require(['config', 'main']); 

Quindi è possibile utilizzare senza l'aggiunta di sempre al vostro definire:

// bar.js 
define([], function() { 
    var key = config.key; 
}); 

Answer 3

Per questo tipo di soluzione, il modulo dovrebbe dipendere da un modulo "config" che è possibile scambiare con uno diverso utilizzando i percorsi di configurazione. Quindi, se "bar" aveva bisogno di un po 'di configurazione, "bar.js" sarebbe simile:

define(['barConfig'], function (config) { 
}); 

Poi barConfig.js potrebbe avere il altre dipendenze:

define(['crypto'], function (crypto) { 
    return { 
     key: crypto.randomBytes(64) 
    } 
}); 

Quindi, se avete bisogno di diverse configurazioni per diciamo, produzione vs.dev, utilizzare i percorsi di configurazione da mappare barConfig ad altri valori:

requirejs.config({ 
    paths: { 
    barConfig: 'barConfig-prod' 
    } 
}); 

Answer 4

riffing su ciò che @jrburke sta dicendo, ho trovato il seguente schema di essere molto utile: definire un modulo di configurazione ed è dipendenze nel main.js poco prima della invocazione di require.config().

main.js

define('config', ['crypto'], function (crypto) { 
    return { 
    'bar': { 
     key: crypto.randomBytes(64) 
    }, 
    }; 
}); 

requirejs.config({ 
    deps: ['app'], 
}); 

app.js

require(['config'], function (config){ 

    // outputs value of: crypto.bar.key 
    console.log(config.bar.key); 
}); 

Plnkr Demo: http://plnkr.co/edit/I35bEgaazEAMD0u4cNuj