--- /dev/null
+define("dojo/_base/config", ["../has", "require"], function(has, require){
+ // module:
+ // dojo/_base/config
+
+/*=====
+return {
+ // summary:
+ // This module defines the user configuration during bootstrap.
+ // description:
+ // By defining user configuration as a module value, an entire configuration can be specified in a build,
+ // thereby eliminating the need for sniffing and or explicitly setting in the global variable dojoConfig.
+ // Also, when multiple instances of dojo exist in a single application, each will necessarily be located
+ // at an unique absolute module identifier as given by the package configuration. Implementing configuration
+ // as a module allows for specifying unique, per-instance configurations.
+ // example:
+ // Create a second instance of dojo with a different, instance-unique configuration (assume the loader and
+ // dojo.js are already loaded).
+ // | // specify a configuration that creates a new instance of dojo at the absolute module identifier "myDojo"
+ // | require({
+ // | packages:[{
+ // | name:"myDojo",
+ // | location:".", //assume baseUrl points to dojo.js
+ // | }]
+ // | });
+ // |
+ // | // specify a configuration for the myDojo instance
+ // | define("myDojo/config", {
+ // | // normal configuration variables go here, e.g.,
+ // | locale:"fr-ca"
+ // | });
+ // |
+ // | // load and use the new instance of dojo
+ // | require(["myDojo"], function(dojo){
+ // | // dojo is the new instance of dojo
+ // | // use as required
+ // | });
+
+ // isDebug: Boolean
+ // Defaults to `false`. If set to `true`, ensures that Dojo provides
+ // extended debugging feedback via Firebug. If Firebug is not available
+ // on your platform, setting `isDebug` to `true` will force Dojo to
+ // pull in (and display) the version of Firebug Lite which is
+ // integrated into the Dojo distribution, thereby always providing a
+ // debugging/logging console when `isDebug` is enabled. Note that
+ // Firebug's `console.*` methods are ALWAYS defined by Dojo. If
+ // `isDebug` is false and you are on a platform without Firebug, these
+ // methods will be defined as no-ops.
+ isDebug: false,
+
+ // locale: String
+ // The locale to assume for loading localized resources in this page,
+ // specified according to [RFC 3066](http://www.ietf.org/rfc/rfc3066.txt).
+ // Must be specified entirely in lowercase, e.g. `en-us` and `zh-cn`.
+ // See the documentation for `dojo.i18n` and `dojo.requireLocalization`
+ // for details on loading localized resources. If no locale is specified,
+ // Dojo assumes the locale of the user agent, according to `navigator.userLanguage`
+ // or `navigator.language` properties.
+ locale: undefined,
+
+ // extraLocale: Array
+ // No default value. Specifies additional locales whose
+ // resources should also be loaded alongside the default locale when
+ // calls to `dojo.requireLocalization()` are processed.
+ extraLocale: undefined,
+
+ // baseUrl: String
+ // The directory in which `dojo.js` is located. Under normal
+ // conditions, Dojo auto-detects the correct location from which it
+ // was loaded. You may need to manually configure `baseUrl` in cases
+ // where you have renamed `dojo.js` or in which `<base>` tags confuse
+ // some browsers (e.g. IE 6). The variable `dojo.baseUrl` is assigned
+ // either the value of `djConfig.baseUrl` if one is provided or the
+ // auto-detected root if not. Other modules are located relative to
+ // this path. The path should end in a slash.
+ baseUrl: undefined,
+
+ // modulePaths: [deprecated] Object
+ // A map of module names to paths relative to `dojo.baseUrl`. The
+ // key/value pairs correspond directly to the arguments which
+ // `dojo.registerModulePath` accepts. Specifying
+ // `djConfig.modulePaths = { "foo": "../../bar" }` is the equivalent
+ // of calling `dojo.registerModulePath("foo", "../../bar");`. Multiple
+ // modules may be configured via `djConfig.modulePaths`.
+ modulePaths: {},
+
+ // addOnLoad: Function|Array
+ // Adds a callback via dojo/ready. Useful when Dojo is added after
+ // the page loads and djConfig.afterOnLoad is true. Supports the same
+ // arguments as dojo/ready. When using a function reference, use
+ // `djConfig.addOnLoad = function(){};`. For object with function name use
+ // `djConfig.addOnLoad = [myObject, "functionName"];` and for object with
+ // function reference use
+ // `djConfig.addOnLoad = [myObject, function(){}];`
+ addOnLoad: null,
+
+ // parseOnLoad: Boolean
+ // Run the parser after the page is loaded
+ parseOnLoad: false,
+
+ // require: String[]
+ // An array of module names to be loaded immediately after dojo.js has been included
+ // in a page.
+ require: [],
+
+ // defaultDuration: Number
+ // Default duration, in milliseconds, for wipe and fade animations within dijits.
+ // Assigned to dijit.defaultDuration.
+ defaultDuration: 200,
+
+ // dojoBlankHtmlUrl: String
+ // Used by some modules to configure an empty iframe. Used by dojo/io/iframe and
+ // dojo/back, and dijit/popup support in IE where an iframe is needed to make sure native
+ // controls do not bleed through the popups. Normally this configuration variable
+ // does not need to be set, except when using cross-domain/CDN Dojo builds.
+ // Save dojo/resources/blank.html to your domain and set `djConfig.dojoBlankHtmlUrl`
+ // to the path on your domain your copy of blank.html.
+ dojoBlankHtmlUrl: undefined,
+
+ // ioPublish: Boolean?
+ // Set this to true to enable publishing of topics for the different phases of
+ // IO operations. Publishing is done via dojo/topic.publish(). See dojo/main.__IoPublish for a list
+ // of topics that are published.
+ ioPublish: false,
+
+ // useCustomLogger: Anything?
+ // If set to a value that evaluates to true such as a string or array and
+ // isDebug is true and Firebug is not available or running, then it bypasses
+ // the creation of Firebug Lite allowing you to define your own console object.
+ useCustomLogger: undefined,
+
+ // transparentColor: Array
+ // Array containing the r, g, b components used as transparent color in dojo.Color;
+ // if undefined, [255,255,255] (white) will be used.
+ transparentColor: undefined,
+
+ // deps: Function|Array
+ // Defines dependencies to be used before the loader has been loaded.
+ // When provided, they cause the loader to execute require(deps, callback)
+ // once it has finished loading. Should be used with callback.
+ deps: undefined,
+
+ // callback: Function|Array
+ // Defines a callback to be used when dependencies are defined before
+ // the loader has been loaded. When provided, they cause the loader to
+ // execute require(deps, callback) once it has finished loading.
+ // Should be used with deps.
+ callback: undefined,
+
+ // deferredInstrumentation: Boolean
+ // Whether deferred instrumentation should be loaded or included
+ // in builds.
+ deferredInstrumentation: true,
+
+ // useDeferredInstrumentation: Boolean|String
+ // Whether the deferred instrumentation should be used.
+ //
+ // * `"report-rejections"`: report each rejection as it occurs.
+ // * `true` or `1` or `"report-unhandled-rejections"`: wait 1 second
+ // in an attempt to detect unhandled rejections.
+ useDeferredInstrumentation: "report-unhandled-rejections"
+};
+=====*/
+
+ var result = {};
+ if( 1 ){
+ // must be the dojo loader; take a shallow copy of require.rawConfig
+ var src = require.rawConfig, p;
+ for(p in src){
+ result[p] = src[p];
+ }
+ }else{
+ var adviseHas = function(featureSet, prefix, booting){
+ for(p in featureSet){
+ p!="has" && has.add(prefix + p, featureSet[p], 0, booting);
+ }
+ };
+ result = 1 ?
+ // must be a built version of the dojo loader; all config stuffed in require.rawConfig
+ require.rawConfig :
+ // a foreign loader
+ this.dojoConfig || this.djConfig || {};
+ adviseHas(result, "config", 1);
+ adviseHas(result.has, "", 1);
+ }
+ return result;
+});
+
git.wh0rd.org / tt-rss.git / blobdiff