Konfigurowanie modułów z RequireJS przy konfiguracji zależy od RequireJS

Question

Przepraszam, jeśli przegapiłem to w dokumentach. Zasadniczo chcę użyć funkcji konfiguracji modułu RequireJS. Chciałbym centralnie zarządzać wartościami konfiguracyjnymi nadanymi modułom w pakiecie.

To jest przykład z docs:

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; 
}); 

Moim problemem jest to, że moje informacje konfiguracja będzie trochę bardziej skomplikowane, a sam ma zależności. Chciałbym wykonać:

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

Gdzie zmienne w mojej konfiguracji muszą używać requireJS do oceny.

Dla mnie sensowne byłoby logiczne oddzielenie konfiguracji RequireJS - konfiguracja niezbędna do ładowania modułów - i konfiguracja modułu użytkownika. Ale jestem obecnie stara się znaleźć to :(

Answer 1

Po myślał o tym trochę więcej I wymyśliłem obejście. Nie jest szczególnie ładna, ale wygląda na to, że działa.

ja po prostu zrobić requireJS (...) dwa razy, najpierw stworzyć config, a po drugie, aby załadować moduły aplikacji z config ..

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() 

aw bar.coffee

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

Answer 2

myślę właściwy sposób to zrobić, aby moduł konfiguracyjny ...

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

następnie używać go w innych modułach ...

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

następnie można zrobić to tak skomplikowane, jak chcesz

EDIT: można zanieczyszczać globalnej przestrzeni nazw dla tej szczególnej klasy ...

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

Dodaj go do najwyższego poziomu wymaga połączenia:

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

Wtedy można go używać bez zawsze dodanie go do zdefiniowania:

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

Answer 3

Dla tego rodzaju rozwiązania chciałbym, aby moduł był zależny od modułu "config", który można zamienić na inny za pomocą konfiguracji ścieżek. Więc jeśli "bar" potrzebował config "bar.js" wyglądałby następująco:

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

Następnie barConfig.js mógłby mieć swój innymi zależnościami:

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

Następnie, jeśli potrzebne różne pliki konfiguracyjne dla powiedzmy, produkcja vs.dev, użyj ścieżki config mapowania barConfig do innych wartości:

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

Answer 4

riffy na co @jrburke mówi, znalazłem następujący wzór, aby być całkiem przydatne: zdefiniować moduł konfiguracyjny oraz jego zależności w main.js tuż przed wywołanie 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