|
|
/// <reference path="dojo.d.ts" />
|
|
|
/// <reference path="_base.d.ts" />
|
|
|
/// <reference path="cldr.d.ts" />
|
|
|
/// <reference path="data.d.ts" />
|
|
|
/// <reference path="date.d.ts" />
|
|
|
/// <reference path="dnd.d.ts" />
|
|
|
/// <reference path="errors.d.ts" />
|
|
|
/// <reference path="io.d.ts" />
|
|
|
/// <reference path="on.d.ts" />
|
|
|
/// <reference path="promise.d.ts" />
|
|
|
/// <reference path="request.d.ts" />
|
|
|
/// <reference path="router.d.ts" />
|
|
|
/// <reference path="rpc.d.ts" />
|
|
|
/// <reference path="selector.d.ts" />
|
|
|
/// <reference path="store.d.ts" />
|
|
|
|
|
|
/**
|
|
|
* The base configuration interface type, which is used when the loader starts and looks
|
|
|
* for the dojoConfig variable.
|
|
|
*/
|
|
|
interface DojoConfig {
|
|
|
/**
|
|
|
* Should the module loader support asyncronous loading, or legacy syncronous
|
|
|
* loading. Defaults to false (legacy mode).
|
|
|
*/
|
|
|
async?: 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?: boolean;
|
|
|
|
|
|
/**
|
|
|
* 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?: string;
|
|
|
|
|
|
/**
|
|
|
* No default value. Specifies additional locales whose
|
|
|
* resources should also be loaded alongside the default locale when
|
|
|
* calls to `dojo.requireLocalization()` are processed.
|
|
|
*/
|
|
|
extraLocale?: 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?: string;
|
|
|
|
|
|
/**
|
|
|
* 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?: { [mid: string]: string };
|
|
|
|
|
|
/**
|
|
|
* 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?: () => void | [any, string];
|
|
|
|
|
|
/**
|
|
|
* Run the parser after the page is loaded
|
|
|
*/
|
|
|
parseOnLoad?: boolean;
|
|
|
|
|
|
/**
|
|
|
* An array of module names to be loaded immediately after dojo.js has been included
|
|
|
* in a page.
|
|
|
*/
|
|
|
require?: string[];
|
|
|
|
|
|
/**
|
|
|
* Default duration, in milliseconds, for wipe and fade animations within dijits.
|
|
|
* Assigned to dijit.defaultDuration.
|
|
|
*/
|
|
|
defaultDuration?: number;
|
|
|
|
|
|
/**
|
|
|
* 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?: string;
|
|
|
|
|
|
/**
|
|
|
* 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?: boolean;
|
|
|
|
|
|
/**
|
|
|
* 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?: any;
|
|
|
|
|
|
/**
|
|
|
* Array containing the r, g, b components used as transparent color in dojo.Color;
|
|
|
* if undefined, ColorValue (white) will be used.
|
|
|
*/
|
|
|
transparentColor?: dojo._base.ColorValue | dojo._base.ColorValueAlpha;
|
|
|
|
|
|
/**
|
|
|
* 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?: (() => string[]) | string[];
|
|
|
|
|
|
/**
|
|
|
* Defines the cached has API variables
|
|
|
*/
|
|
|
hasCache?: dojo.HasCache;
|
|
|
|
|
|
/**
|
|
|
* 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.
|
|
|
*/
|
|
|
callback?: (...args: any[]) => void;
|
|
|
|
|
|
/**
|
|
|
* Whether deferred instrumentation should be loaded or included
|
|
|
* in builds.
|
|
|
*/
|
|
|
deferredInstrumentation?: boolean;
|
|
|
|
|
|
/**
|
|
|
* 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?: string | boolean | number;
|
|
|
|
|
|
/**
|
|
|
* Package configuration to pass to the AMD loader.
|
|
|
*/
|
|
|
packages?: dojo.Package[];
|
|
|
|
|
|
/**
|
|
|
* A map of packages used to configure the AMD loader
|
|
|
*/
|
|
|
map?: dojo.ModuleMap;
|
|
|
}
|
|
|
|
